# DeepSeek-R1 Reasoning Model

{% hint style="success" %}
Alle Beispiele laufen auf GPU-Servern, die über die gemietet werden [CLORE.AI Marketplace](https://clore.ai/marketplace). RTX 4090-Instanzen beginnen bei \~0,50 $/Tag.
{% endhint %}

## Überblick

DeepSeek-R1 ist ein 671-Milliarden-Parameter Open-Weight-Reasoning-Modell, das im Januar 2025 von DeepSeek unter der **Apache 2.0** Lizenz veröffentlicht wurde. Es ist das erste offene Modell, das OpenAI o1 in Mathematik-, Programmier- und wissenschaftlichen Benchmarks erreicht — während es seine gesamte Denkweise über explizite `<think>` Tags offenlegt.

Das vollständige Modell verwendet **Mixture-of-Experts (MoE)** mit 37 Milliarden aktiven Parametern pro Token, wodurch die Inferenz trotz der Schlagzeilenzahl der Parameter praktikabel bleibt. Für die meisten Anwender sind die **distillierten Varianten** (1,5B → 70B) praktischer: Sie übernehmen R1s Denkpatterns durch Wissensdistillation in Qwen-2.5- und Llama-3-Basisarchitekturen und laufen auf handelsüblichen GPUs.

## Hauptmerkmale

* **Explizite Chain-of-Thought** — jede Antwort beginnt mit einem `<think>` Block, in dem das Modell denkt, zurückverfolgt und sich selbst korrigiert, bevor es eine endgültige Antwort liefert
* **Durch Reinforcement Learning trainiert** — die Fähigkeit zum Schließen ergibt sich aus RL-Belohnungssignalen und nicht aus handerstellten Chain-of-Thought-Daten
* **Sechs distillierte Varianten** — 1,5B, 7B, 8B, 14B, 32B, 70B Parameter-Modelle, vom vollständigen 671B in Qwen- und Llama-Architekturen distilliert
* **Apache-2.0-Lizenz** — vollständig kommerziell, keine Lizenzgebühren, keine Nutzungsbeschränkungen
* **Breite Framework-Unterstützung** — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI funktionieren alle sofort
* **AIME 2024 Pass\@1: 79,8 %** — gleichauf mit OpenAI o1 bei Wettbewerbs-Mathematik
* **Codeforces 2029 Elo** — übertrifft o1s 1891 im Wettbewerbprogrammieren

## Modellvarianten

| Variante                 | Parameter        | Architektur  | FP16 VRAM | Q4 VRAM  | Q4 Festplatte |
| ------------------------ | ---------------- | ------------ | --------- | -------- | ------------- |
| DeepSeek-R1 (volles MoE) | 671B (37B aktiv) | DeepSeek MoE | \~1,3 TB  | \~350 GB | \~340 GB      |
| R1-Distill-Llama-70B     | 70B              | Llama 3      | 140 GB    | 40 GB    | 42 GB         |
| R1-Distill-Qwen-32B      | 32B              | Qwen 2.5     | 64 GB     | 22 GB    | 20 GB         |
| R1-Distill-Qwen-14B      | 14B              | Qwen 2.5     | 28 GB     | 10 GB    | 9 GB          |
| R1-Distill-Llama-8B      | 8B               | Llama 3      | 16 GB     | 6 GB     | 5,5 GB        |
| R1-Distill-Qwen-7B       | 7B               | Qwen 2.5     | 14 GB     | 5 GB     | 4,5 GB        |
| R1-Distill-Qwen-1.5B     | 1.5B             | Qwen 2.5     | 3 GB      | 2 GB     | 1,2 GB        |

### Wahl einer Variante

| Einsatzgebiet                                 | Empfohlene Variante    | GPU auf Clore                  |
| --------------------------------------------- | ---------------------- | ------------------------------ |
| Schnelle Experimente, Edge-Tests              | R1-Distill-Qwen-1.5B   | Beliebige GPU                  |
| Budget-Bereitstellung, schnelle Inferenz      | R1-Distill-Qwen-7B     | RTX 3090 (\~0,30–1 $/Tag)      |
| Sweetspot für Single-GPU-Produktion           | R1-Distill-Qwen-14B Q4 | RTX 4090 (\~0,50–2 $/Tag)      |
| Bestes Preis-Leistungs-Verhältnis (empfohlen) | R1-Distill-Qwen-32B Q4 | RTX 4090 24 GB oder A100 40 GB |
| Maximale distillierte Qualität                | R1-Distill-Llama-70B   | 2× A100 80 GB                  |
| Forschung, vollauflösendes Reasoning          | DeepSeek-R1 671B       | 8× H100-Cluster                |

### HuggingFace-Repositories

| Variante          | Repository                                                                                                    |
| ----------------- | ------------------------------------------------------------------------------------------------------------- |
| Volles R1         | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Llama-70B-Distill | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Qwen-32B-Distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Qwen-14B-Distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Llama-8B-Distill  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Qwen-7B-Distill   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Qwen-1.5B-Distill | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## Anforderungen

| Komponente | Minimum (7B Q4) | Empfohlen (32B Q4) |
| ---------- | --------------- | ------------------ |
| GPU-VRAM   | 6 GB            | 24 GB              |
| System-RAM | 16 GB           | 32 GB              |
| Festplatte | 10 GB           | 30 GB              |
| CUDA       | 12.1+           | 12.4+              |
| Docker     | 24.0+           | 25.0+              |

## Ollama Quick Start

Ollama übernimmt Quantisierung, Herunterladen und Serving automatisch — der schnellste Weg zu einem laufenden DeepSeek-R1.

### Installieren und ausführen

```bash
# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# Herunterziehen und ausführen (wähle deine Variante):
ollama run deepseek-r1:1.5b    # Edge / Test
ollama run deepseek-r1:7b      # Budget — passt auf jede GPU mit 8 GB+
ollama run deepseek-r1:14b     # RTX 4090 Sweetspot
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB
```

### Beispiel einer interaktiven Sitzung

```
>>> Beweise, dass √2 irrational ist.

<think>
Ich werde den Beweis durch Widerspruch verwenden.
Angenommen √2 ist rational, also √2 = p/q, wobei p,q ganze Zahlen mit gcd(p,q) = 1 sind.
Dann ist 2 = p²/q², was p² = 2q² ergibt.
Das bedeutet, p² ist gerade, also muss p gerade sein. Schreibe p = 2k.
Einsetzen: (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Also ist auch q² gerade, was bedeutet, dass q gerade ist.
Wenn jedoch sowohl p als auch q gerade sind, ist gcd(p,q) ≥ 2, was unserer Annahme widerspricht.
</think>

**Beweis, dass √2 irrational ist (durch Widerspruch):**

Angenommen √2 = p/q in kleinstmöglichen Termen (gcd(p,q) = 1). Quadrieren ergibt p² = 2q².
Da p² gerade ist, ist p gerade — schreibe p = 2k. Dann 4k² = 2q², also q² = 2k²,
was bedeutet, dass q ebenfalls gerade ist. Das widerspricht gcd(p,q) = 1. ∎
```

### Verwende die OpenAI-kompatible API

```bash
# Starte Ollama als Server (falls nicht bereits laufend)
ollama serve &

# Abfragen via curl
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Faktorisieren Sie x^4 - 1 vollständig über den ganzen Zahlen."}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Python-Client (via OpenAI SDK)

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "Schreibe eine Python-Funktion, die die längste palindromische Teilzeichenfolge findet."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## vLLM Produktions-Setup

vLLM liefert den höchsten Durchsatz für Multi-User-Serving mit kontinuierlichem Batching, PagedAttention und Prefix-Caching.

### Single GPU — 7B / 14B

```bash
pip install vllm

# 7B auf jeder 16 GB+ GPU
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B auf RTX 4090 (24 GB)
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92
```

### Multi-GPU — 32B (empfohlen)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching
```

> **Tipp:** Der 32B Q4 GPTQ- oder AWQ-Checkpoint passt auf eine einzelne RTX 4090 (24 GB):
>
> ```bash
> vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
>     --quantization awq --host 0.0.0.0 --port 8000 \
>     --max-model-len 16384
> ```

### Multi-GPU — 70B

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90
```

### Frage den vLLM-Endpunkt ab

```bash
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "Löse: Finde alle Primzahlen p, sodass p^2 + 2 ebenfalls prim ist."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (mit `<think>` Tag-Parsing)

Verwende HuggingFace Transformers, wenn du feinkörnige Kontrolle über die Generierung brauchst oder R1 in eine Python-Pipeline integrieren möchtest.

### Basisgenerierung

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch, re

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

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

prompt = "Was ist die Summe der ersten 100 positiven ganzen Zahlen?"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)
```

### Parsing `<think>` Tags

```python
def parse_r1_response(text: str) -> dict:
    """Zerlege eine DeepSeek-R1-Antwort in Denk- und Antwortteile."""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"Das Modell hat {result['thinking_tokens']} Wörter für das Denken verwendet")
print(f"Antwort: {result['answer']}")
```

### Streaming mit `<think>` Statusverfolgung

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="unused")

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "Leite die quadratische Formel aus ax² + bx + c = 0 her."}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[Reasoning] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Answer] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()
```

## Docker-Bereitstellung auf Clore.ai

### Ollama Docker (einfachste Lösung)

**Docker-Image:** `ollama/ollama` **Ports:** `22/tcp, 11434/http`

```bash
# Auf der Clore-Instanz
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# Modell herunterladen und bereitstellen
docker exec deepseek-r1 ollama pull deepseek-r1:32b
```

### vLLM Docker (Produktion)

**Docker-Image:** `vllm/vllm-openai:latest` **Ports:** `22/tcp, 8000/http`

```yaml
# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:
```

Bereitstellen auf Clore.ai:

1. Öffnen [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtern nach **2× GPU, insgesamt 48 GB+ VRAM** (z. B. 2× RTX 4090 oder A100 80 GB)
3. Setze das Docker-Image auf `vllm/vllm-openai:latest`
4. Port mappen **8000** als HTTP
5. Füge den Befehl aus der obigen Compose-Datei in den Startbefehl ein
6. Verbinde über den HTTP-Endpunkt, sobald der Health-Check bestanden ist

## Tipps für Clore.ai-Bereitstellungen

### Wahl der richtigen GPU

| Budget        | GPU              | Tägliche Kosten | Beste Variante                       |
| ------------- | ---------------- | --------------- | ------------------------------------ |
| Minimal       | RTX 3090 (24 GB) | 0,30 $ – 1,00 $ | R1-Distill-Qwen-7B oder 14B Q4       |
| Standard      | RTX 4090 (24 GB) | 0,50 $ – 2,00 $ | R1-Distill-Qwen-14B FP16 oder 32B Q4 |
| Produktion    | A100 80 GB       | 3 $ – 8 $       | R1-Distill-Qwen-32B FP16             |
| Hohe Qualität | 2× A100 80 GB    | 6 $ – 16 $      | R1-Distill-Llama-70B FP16            |

### Performance-Tuning

* **Temperature 0.6** ist die empfohlene Standardeinstellung für Reasoning-Aufgaben — DeepSeeks eigene Paper verwenden diesen Wert
* **Setze `max_tokens` großzügig** — Reasoning-Modelle produzieren lange `<think>` Blöcke; 4096+ für nicht-triviale Probleme
* **Prefix-Caching aktivieren** (`--enable-prefix-caching` in vLLM) bei Verwendung eines geteilten System-Prompts
* **Parallelität begrenzen** (`--max-num-seqs 16`) für Reasoning-Workloads — jede Anfrage verwendet mehr Rechenleistung als ein Standard-Chat
* **Verwende Q4-Quantisierung** um 32B auf eine einzelne 24-GB-GPU mit minimalem Qualitätsverlust zu packen (die Distillation komprimiert R1s Wissen bereits)

### Überlegungen zur Kontextlänge

Reasoning-Modelle verbrauchen mehr Kontext als Standard-Chat-Modelle wegen des `<think>` Blocks:

| Aufgabenkomplexität              | Typische Denk-Länge | Benötigter Gesamtkontext |
| -------------------------------- | ------------------- | ------------------------ |
| Einfache Arithmetik              | \~100 Tokens        | \~300 Tokens             |
| Code-Generierung                 | \~500–1000 Tokens   | \~2000 Tokens            |
| Wettbewerbs-Mathematik (AIME)    | \~2000–4000 Tokens  | \~5000 Tokens            |
| Mehrschrittige Forschungsanalyse | \~4000–8000 Tokens  | \~10000 Tokens           |

## Fehlerbehebung

### Out of memory (OOM)

```bash
# Kontextlänge reduzieren
--max-model-len 8192    # anstelle von 32768

# Begrenze parallele Sequenzen
--max-num-seqs 8

# Verwende Quantisierung
--quantization awq      # oder gptq
```

### Modell erzeugt keinen `<think>` Block

Einige System-Prompts unterdrücken das Denken. Vermeide Anweisungen wie „sei knapp“ oder „erkläre deine Überlegungen nicht.“ Verwende ein minimales System-Prompt oder gar keines:

```python
# Gut — bewahrt das Reasoning
messages = [{"role": "user", "content": "..."}]

# Schlecht — kann das Denken unterdrücken
messages = [
    {"role": "system", "content": "Sei extrem kurz. Keine Erklärungen."},
    {"role": "user", "content": "..."}
]
```

### Wiederholende oder sich wiederholende `<think>` Ausgabe

Verringere die Temperature, um die Zufälligkeit in der Denk-Kette zu reduzieren:

```python
temperature = 0.0   # Deterministisch — am besten für Mathematik/Code
temperature = 0.3   # Leichte Variation — gut für Analyse
```

### Langsames erstes Token (hoher TTFT)

Das ist zu erwarten — das Modell erzeugt `<think>` Tokens vor der sichtbaren Antwort. Für latenzempfindliche Anwendungen, in denen kein Reasoning benötigt wird, verwende [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-v3) stattdessen.

### Download stockt auf Clore-Instanz

HuggingFace-Downloads können bei einigen Anbietern langsam sein. Cache das Modell vorab in ein persistentes Volume:

```bash
# Einmal in ein Volume herunterladen
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# Weisen Sie vLLM auf den lokalen Pfad hin
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000
```

## Weiterführende Lektüre

* [DeepSeek-R1 Paper](https://arxiv.org/abs/2501.12948) — *Incentivizing Reasoning Capability in LLMs via Reinforcement Learning*
* [DeepSeek-R1 GitHub](https://github.com/deepseek-ai/DeepSeek-R1) — Offizielles Repository mit Model-Cards
* [DeepSeek-V3 Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-v3) — Nicht-Reasoning-Allzweckmodell aus demselben Labor
* [vLLM-Leitfaden](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — Umfassendes Produktions-Serving-Setup
* [Ollama-Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — Einfache lokale Bereitstellung für jedes Modell
* [Open WebUI Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/open-webui) — Chat-UI mit nativer `<think>` Tag-Darstellung
* [Qwen 2.5 Anleitung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/qwen25) — Die Basisarchitektur, die von den meisten R1-Distills verwendet wird