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 la place de marché CLORE.AI. Les instances RTX 4090 commencent à 0,14–0,42 $/h.

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 programmation et scientifiques — tout en exposant l’intégralité de sa chaîne de pensée via des <think> balises.

Le modèle complet utilise Mélange d’experts (MoE) avec 37 milliards de paramètres actifs par jeton, ce qui rend l’inférence faisable malgré le nombre total de paramètres mis en avant. 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 grâce à la distillation de connaissances dans les architectures de base Qwen-2.5 et Llama-3, et fonctionnent sur des GPU grand public.

Caractéristiques clés

• Chaîne de pensée 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 de signaux de récompense de RL plutôt que de données de chaîne de pensée rédigées à la main

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

• licence Apache 2.0 — utilisation commerciale totale, sans redevances ni restrictions d’utilisation

• Large prise en charge des frameworks — Ollama, vLLM, llama.cpp, SGLang, Transformers et 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 le 1891 de 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)	MoE DeepSeek	~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 à petit budget, inférence rapide	R1-Distill-Qwen-7B	RTX 3090 (0,07–0,21 $/h)
Le compromis idéal pour la production sur un seul GPU	R1-Distill-Qwen-14B Q4	RTX 4090 (0,14–0,42 $/h)
Meilleur rapport qualité/prix (recommandé)	R1-Distill-Qwen-32B Q4	RTX 4090 24 Go ou A100 40 Go
Qualité distillée maximale	R1-Distill-Llama-70B	2× A100 80 Go
Recherche, raisonnement en pleine fidélité	DeepSeek-R1 671B	cluster de 8× H100

Dépôts HuggingFace

Variante	Dépôt
R1 complet	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

Exigences

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

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.8+	12.8+
Docker	24.0+	25.0+

Démarrage rapide avec Ollama

Ollama gère automatiquement la quantification, le téléchargement et le service — la voie la plus rapide pour faire fonctionner DeepSeek-R1.

Installer et exécuter

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

# Récupérez et exécutez (choisissez votre variante) :
ollama run deepseek-r1:1.5b    # Périphérie / tests
ollama run deepseek-r1:7b      # Petit budget — convient à tout GPU de 8 Go+
ollama run deepseek-r1:14b     # Le choix idéal pour une RTX 4090
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 Go

Exemple de session interactive

>>> Prouvez que √2 est irrationnel.

<think>
Je vais utiliser une preuve par l’absurde.
Supposons que √2 soit rationnel, donc √2 = p/q où p et q sont des entiers tels que pgcd(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 remplaçant : (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Donc q² est aussi pair, ce qui signifie que q est pair.
Mais si p et q sont tous deux pairs, pgcd(p,q) ≥ 2, ce qui contredit notre hypothèse.
</think>

**Preuve que √2 est irrationnel (par l’absurde) :**

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

Utilisez l’API compatible avec OpenAI

# Démarrez Ollama en tant que serveur (si ce n’est pas déjà fait)
ollama serve &

# Interrogez via curl
curl -s http://localhost:11434/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Factorisez complètement x^4 - 1 sur les entiers."}],
    "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": "Écrivez 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 de production vLLM

vLLM offre le débit le plus élevé pour le service multi-utilisateur grâce au batching continu, à PagedAttention et au cache de préfixe.

Un seul GPU — 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 Go)
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

Astuce : Le checkpoint 32B Q4 GPTQ ou AWQ tient sur une seule RTX 4090 (24 Go) :

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

Interrogez 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": "Résoudre : trouver tous les nombres premiers p tels que p^2 + 2 soit également premier."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'

Transformers / Python (avec <think> analyse des balises)

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(
    MODEL,
    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> des balises

def parse_r1_response(text: str) -> dict:
    """Sépare une réponse DeepSeek-R1 en parties réflexion et 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

Docker Ollama (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érez et servez le modèle
docker exec deepseek-r1 ollama pull deepseek-r1:32b

Docker vLLM (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:-}
    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:

Déployez sur Clore.ai :

1. Ouvrez clore.ai/marketplace

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

3. Définissez l’image Docker sur vllm/vllm-openai:latest

4. Mappez 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 la vérification de santé réussie

Conseils pour les déploiements Clore.ai

Choisir le bon GPU

Petit budget	GPU	Coût journalier	Meilleure variante
Minime	RTX 3090 (24 Go)	0,30–1,00 $	R1-Distill-Qwen-7B ou 14B Q4
Standard	RTX 4090 (24 Go)	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 Go	6–16 $	R1-Distill-Llama-70B FP16

Optimisation 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éfinissez max_tokens généreusement — les modèles de raisonnement produisent de longs <think> blocs ; 4096+ pour les problèmes non triviaux

• Activez le cache de préfixe (--enable-prefix-caching dans vLLM) lorsque vous utilisez un prompt système partagé

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

• Utilisez la quantification Q4 pour faire tenir 32B sur un seul GPU de 24 Go 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 standard à cause du <think> bloc :

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

Dépannage

Mémoire insuffisante (OOM)

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

# Limitez les séquences concurrentes
--max-num-seqs 8

# Utilisez la quantification
--quantization awq      # ou gptq

Le modèle ne produit aucun <think> bloc

Certains prompts système suppriment la réflexion. Évitez les instructions comme « soyez concis » ou « n’expliquez pas votre raisonnement ». Utilisez un prompt système minimal, ou aucun du tout :

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

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

Répétitif ou en boucle <think> sortie

Abaissez la température pour réduire l’aléa dans la chaîne de raisonnement :

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

Premier jeton lent (TTFT élevé)

C’est normal — le modèle génère <think> jetons 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 se bloque sur l’instance Clore

Les téléchargements HuggingFace peuvent être lents chez certains fournisseurs. Mettez le modèle en cache à l’avance dans un volume persistant :

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

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

Pour aller plus loin

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

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

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

• Guide vLLM — Configuration complète de service en production

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

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

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