Modèle de raisonnement DeepSeek-R1

Exécutez le modèle de raisonnement open-source DeepSeek-R1 sur les GPU Clore.ai

Tous les exemples s'exécutent sur des serveurs GPU loués via le CLORE.AI Marketplace. Les instances RTX 4090 commencent à ~0,50 $/jour.

Aperçu

DeepSeek-R1 est un modèle de raisonnement à poids ouverts de 671 milliards de paramètres publié en janvier 2025 par DeepSeek sous la Apache 2.0 licence. C'est le premier modèle ouvert à égaler OpenAI o1 sur les benchmarks de mathématiques, de codage et scientifiques — tout en exposant toute sa chaîne de raisonnement via des <think> étiquettes.

Le modèle complet utilise Mélange d'Experts (MoE) avec 37 milliards de paramètres actifs par token, rendant l'inférence gérable malgré le nombre de paramètres annoncé. Pour la plupart des praticiens, les variantes distillées (1,5B → 70B) sont plus pratiques : elles héritent des schémas de raisonnement de R1 par distillation des connaissances dans les architectures de base Qwen-2.5 et Llama-3 et s'exécutent sur des GPU grand public.

Principales caractéristiques

• Chaîne de raisonnement explicite — chaque réponse commence par un <think> bloc où le modèle raisonne, revient en arrière et se corrige avant de produire une réponse finale

• Entraîné par apprentissage par renforcement — la capacité de raisonnement émerge des signaux de récompense RL plutôt que de données de chaîne de raisonnement écrites à la main

• Six variantes distillées — modèles de 1,5B, 7B, 8B, 14B, 32B, 70B paramètres distillés à partir du 671B complet dans les architectures Qwen et Llama

• Licence Apache 2.0 — entièrement commercial, sans redevances, sans restrictions d'utilisation

• Large prise en charge des frameworks — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI fonctionnent tous immédiatement

• AIME 2024 Pass@1 : 79,8 % — à égalité avec OpenAI o1 en mathématiques de compétition

• Elo Codeforces 2029 — dépasse les 1891 d'o1 en programmation compétitive

Variantes de modèle

Variante	Paramètres	Architecture	VRAM FP16	VRAM Q4	Disque Q4
DeepSeek-R1 (MoE complet)	671B (37B actifs)	DeepSeek MoE	~1,3 To	~350 Go	~340 Go
R1-Distill-Llama-70B	70B	Llama 3	140 Go	40 Go	42 Go
R1-Distill-Qwen-32B	32B	Qwen 2.5	64 Go	22 Go	20 Go
R1-Distill-Qwen-14B	14B	Qwen 2.5	28 Go	10 Go	9 Go
R1-Distill-Llama-8B	8B	Llama 3	16 Go	6 Go	5,5 Go
R1-Distill-Qwen-7B	7B	Qwen 2.5	14 Go	5 Go	4,5 Go
R1-Distill-Qwen-1.5B	1,5B	Qwen 2.5	3 Go	2 Go	1,2 Go

Choisir une variante

Cas d'utilisation	Variante recommandée	GPU sur Clore
Expériences rapides, tests en périphérie	R1-Distill-Qwen-1.5B	N'importe quel GPU
Déploiement à budget, inférence rapide	R1-Distill-Qwen-7B	RTX 3090 (~0,30–1 $/jour)
Point idéal pour la production sur GPU unique	R1-Distill-Qwen-14B Q4	RTX 4090 (~0,50–2 $/jour)
Meilleur rapport qualité-prix (recommandé)	R1-Distill-Qwen-32B Q4	RTX 4090 24 GB ou A100 40 GB
Qualité distillée maximale	R1-Distill-Llama-70B	2× A100 80 GB
Recherche, raisonnement en pleine fidélité	DeepSeek-R1 671B	Cluster 8× H100

Dépôts HuggingFace

Variante	Dépôt
R1 complet	deepseek-ai/DeepSeek-R1
Distill Llama-70B	deepseek-ai/DeepSeek-R1-Distill-Llama-70B
Distill Qwen-32B	deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
Distill Qwen-14B	deepseek-ai/DeepSeek-R1-Distill-Qwen-14B
Distill Llama-8B	deepseek-ai/DeepSeek-R1-Distill-Llama-8B
Distill Qwen-7B	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
Distill Qwen-1.5B	deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

Exigences

Composant	Minimum (7B Q4)	Recommandé (32B Q4)
VRAM GPU	6 Go	24 Go
RAM système	16 Go	32 Go
Disque	10 Go	30 Go
CUDA	12.1+	12.4+
Docker	24.0+	25.0+

Démarrage rapide Ollama

Ollama gère automatiquement la quantification, le téléchargement et la mise en service — le chemin le plus rapide vers un DeepSeek-R1 opérationnel.

Installer et exécuter

# Installer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Récupérer et exécuter (choisissez votre variante) :
ollama run deepseek-r1:1.5b    # Périphérie / tests
ollama run deepseek-r1:7b      # Budget — convient à tout GPU de 8 Go+
ollama run deepseek-r1:14b     # Point idéal RTX 4090
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB

Exemple de session interactive

>>> Prouvez que √2 est irrationnel.

<think>
J'utiliserai une démonstration par l'absurde.
Supposons que √2 soit rationnel, donc √2 = p/q où p,q sont des entiers avec gcd(p,q) = 1.
Alors 2 = p²/q², ce qui donne p² = 2q².
Cela signifie que p² est pair, donc p doit être pair. Écrivons p = 2k.
En substituant : (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Ainsi q² est aussi pair, ce qui signifie que q est pair.
Mais si p et q sont tous deux pairs, gcd(p,q) ≥ 2, contredisant notre hypothèse.
</think>

**Démonstration que √2 est irrationnel (par l'absurde) :**

Supposons √2 = p/q sous forme irréductible (gcd(p,q) = 1). En élevant au carré on obtient p² = 2q².
Puisque p² est pair, p est pair — écrivons p = 2k. Alors 4k² = 2q², donc q² = 2k²,
ce qui signifie que q est également pair. Cela contredit gcd(p,q) = 1. ∎

Utilisez l'API compatible OpenAI

# Démarrer Ollama en tant que serveur (si ce n'est pas déjà en cours)
ollama serve &

# Interroger via curl
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Factor x^4 - 1 completely over the integers."}],
    "temperature": 0.6
  }' | python3 -m json.tool

Client Python (via le SDK OpenAI)

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": "Écrire une fonction Python pour trouver la plus longue sous-chaîne palindromique."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)

Configuration vLLM pour la production

vLLM offre le débit le plus élevé pour la mise en service multi-utilisateurs avec regroupement continu, PagedAttention et mise en cache de préfixe.

GPU unique — 7B / 14B

pip install vllm

# 7B sur n'importe quel GPU de 16 Go+
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B sur 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 (recommandé)

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

Conseil : Le point de contrôle 32B Q4 GPTQ ou AWQ tient sur un seul 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

Interroger le point de terminaison vLLM

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": "Solve: find all primes p such that p^2 + 2 is also prime."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'

Transformers / Python (avec <think> Analyse d'étiquettes)

Utilisez HuggingFace Transformers lorsque vous avez besoin d'un contrôle fin sur la génération ou que vous souhaitez intégrer R1 dans un pipeline Python.

Génération de base

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(
    MODÈLE,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "Quelle est la somme des 100 premiers entiers positifs ?"
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)

Analyse <think> étiquettes

def parse_r1_response(text: str) -> dict:
    """Sépare une réponse DeepSeek-R1 en parties de réflexion et de réponse."""
    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"Le modèle a raisonné pendant {result['thinking_tokens']} mots")
print(f"Réponse : {result['answer']}")

Streaming avec <think> suivi d'état

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": "Dérivez la formule quadratique à partir de ax² + bx + c = 0."}],
    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("[Raisonnement] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Réponse] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()

Déploiement Docker sur Clore.ai

Ollama Docker (le plus simple)

Image Docker : ollama/ollama Ports : 22/tcp, 11434/http

# Sur l'instance Clore
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# Récupérer et servir le modèle
docker exec deepseek-r1 ollama pull deepseek-r1:32b

vLLM Docker (production)

Image Docker : 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:-}
    commande : >
      --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"]
      intervalle : 30s
      timeout : 10s
      retries : 5
      start_period: 300s
volumes :
  hf_cache :

Déployer sur Clore.ai :

1. Ouvrir clore.ai/marketplace

2. Filtrer par 2× GPU, 48 Go+ VRAM total (par ex. 2× RTX 4090 ou A100 80 GB)

3. Définir l'image Docker sur vllm/vllm-openai:latest

4. Mapper le port 8000 en HTTP

5. Collez la commande du fichier compose ci-dessus dans la commande de démarrage

6. Connectez-vous via le point de terminaison HTTP une fois que le contrôle de santé est passé

Conseils pour les déploiements Clore.ai

Choisir le bon GPU

Économique	GPU	Coût journalier	Meilleure variante
Minimale	RTX 3090 (24 GB)	0,30 $ – 1,00 $	R1-Distill-Qwen-7B ou 14B Q4
Standard	RTX 4090 (24 GB)	0,50 $ – 2,00 $	R1-Distill-Qwen-14B FP16 ou 32B Q4
Production	A100 80 Go	3 $ – 8 $	R1-Distill-Qwen-32B FP16
Haute qualité	2× A100 80 GB	6 $ – 16 $	R1-Distill-Llama-70B FP16

Ajustement des performances

• Température 0,6 est la valeur par défaut recommandée pour les tâches de raisonnement — les propres articles de DeepSeek utilisent cette valeur

• Définir max_tokens généreusement — les modèles de raisonnement produisent de longs <think> blocs ; 4096+ pour des problèmes non triviaux

• Activer la mise en cache de préfixe (--enable-prefix-caching dans vLLM) lors de l'utilisation d'une invite système partagée

• Limiter la concurrence (--max-num-seqs 16) pour les charges de travail de raisonnement — chaque requête utilise plus de calcul qu'un chat standard

• Utiliser la quantification Q4 pour faire tenir 32B sur un seul GPU 24 GB avec une perte de qualité minimale (la distillation compresse déjà les connaissances de R1)

Considérations sur la longueur du contexte

Les modèles de raisonnement consomment plus de contexte que les modèles de chat standards en raison du <think> bloc :

Complexité de la tâche	Longueur de réflexion typique	Contexte total nécessaire
Arithmétique simple	~100 tokens	~300 tokens
Génération de code	~500–1000 tokens	~2000 tokens
Mathématiques de compétition (AIME)	~2000–4000 tokens	~5000 tokens
Analyse de recherche en plusieurs étapes	~4000–8000 tokens	~10000 tokens

Dépannage

Mémoire insuffisante (OOM)

# Réduire la longueur du contexte
--max-model-len 8192    # au lieu de 32768

# Limiter les séquences simultanées
--max-num-seqs 8

# Utiliser la quantification
--quantization awq      # ou gptq

Le modèle ne produit pas de <think> bloc

Certaines invites système suppriment la réflexion. Évitez les instructions comme « soyez concis » ou « n'expliquez pas votre raisonnement ». Utilisez une invite système minimale ou aucune :

# Bon — préserve le raisonnement
messages = [{"role": "user", "content": "..."}]

# Mauvais — peut supprimer la réflexion
messages = [
    {"role": "system", "content": "Soyez extrêmement bref. Pas d'explications."},
    {"role": "user", "content": "..."}
]

Sortie répétitive ou en boucle <think> sortie

Réduisez la température pour diminuer l'aléa dans la chaîne de raisonnement :

temperature = 0.0   # Déterministe — meilleur pour les maths/le code
temperature = 0.3   # Légère variation — bon pour l'analyse

Premier token lent (TTFT élevé)

Ceci est attendu — le modèle génère <think> tokens avant la réponse visible. Pour les applications sensibles à la latence où le raisonnement n'est pas nécessaire, utilisez DeepSeek-V3 à la place.

Le téléchargement stagne sur l'instance Clore

Les téléchargements HuggingFace peuvent être lents chez certains fournisseurs. Pré-cachez le modèle dans un volume persistant :

# Télécharger une fois dans un volume
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# Indiquer vLLM vers le chemin local
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000

Lectures complémentaires

• Article DeepSeek-R1 — Inciter la capacité de raisonnement dans les LLMs via l'apprentissage par renforcement

• DeepSeek-R1 GitHub — Dépôt officiel avec fiches des modèles

• Guide DeepSeek-V3 — Modèle généraliste non axé sur le raisonnement du même laboratoire

• - Débit le plus élevé — Configuration complète de service pour la production

• Guide Ollama — Déploiement local simple pour n'importe quel modèle

• Guide Open WebUI — Interface de chat avec rendu natif <think> de balises

• Guide Qwen 2.5 — L'architecture de base utilisée par la plupart des distills R1