DeepSeek-R1 Reasoning-Modell

Führen Sie das Open-Source-Reasoning-Modell DeepSeek-R1 auf Clore.ai GPUs aus

Alle Beispiele laufen auf GPU-Servern, die über die gemietet werden CLORE.AI Marketplace. RTX 4090-Instanzen beginnen bei ~0,50 $/Tag.

Ü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
Llama-70B-Distill	deepseek-ai/DeepSeek-R1-Distill-Llama-70B
Qwen-32B-Distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
Qwen-14B-Distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-14B
Llama-8B-Distill	deepseek-ai/DeepSeek-R1-Distill-Llama-8B
Qwen-7B-Distill	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
Qwen-1.5B-Distill	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

# 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

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

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

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)

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

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

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

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

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

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

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

# 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

# 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

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)

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

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

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

Download stockt auf Clore-Instanz

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

# 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 — Incentivizing Reasoning Capability in LLMs via Reinforcement Learning

• DeepSeek-R1 GitHub — Offizielles Repository mit Model-Cards

• DeepSeek-V3 Anleitung — Nicht-Reasoning-Allzweckmodell aus demselben Labor

• vLLM-Leitfaden — Umfassendes Produktions-Serving-Setup

• Ollama-Anleitung — Einfache lokale Bereitstellung für jedes Modell

• Open WebUI Anleitung — Chat-UI mit nativer <think> Tag-Darstellung

• Qwen 2.5 Anleitung — Die Basisarchitektur, die von den meisten R1-Distills verwendet wird