# Modèle de raisonnement DeepSeek-R1

{% hint style="success" %}
Tous les exemples s’exécutent sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace). Les instances RTX 4090 commencent à environ 0,50 $/jour.
{% endhint %}

## Aperçu

DeepSeek-R1 est un modèle de raisonnement à poids ouverts de 671B 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 code et de science — tout en exposant l’intégralité de sa chaîne de pensée via des `<think>` balises.

Le modèle complet utilise **Mixture-of-Experts (MoE)** avec 37B de paramètres actifs par jeton, ce qui rend l’inférence praticable malgré le nombre total 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 via une distillation de connaissances dans les architectures de base Qwen-2.5 et Llama-3, et s’exécutent sur des GPU grand public.

## Fonctionnalités clés

* **Chaîne de pensée explicite** — chaque réponse commence par un `<think>` bloc dans lequel le modèle raisonne, revient en arrière et s’auto-corrige avant de produire une réponse finale
* **Entraîné par apprentissage par renforcement** — la capacité de raisonnement émerge des 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** — entièrement commercial, sans redevances, sans restrictions d’utilisation
* **Large support 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
* **Codeforces 2029 Elo** — dépasse le 1891 de o1 en programmation compétitive

## Variantes de modèles

| 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érimentations 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,30–1 $/jour)                                                                                                  |
| Point idéal pour la production sur un seul GPU | R1-Distill-Qwen-14B Q4 | [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) (\~0,50–2 $/jour)   |
| Meilleur rapport qualité-prix (recommandé)     | R1-Distill-Qwen-32B Q4 | [RTX 4090 24 Go](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) ou A100 40 Go |
| Qualité distillée maximale                     | R1-Distill-Llama-70B   | 2× A100 80 Go                                                                                                               |
| Recherche, raisonnement en fidélité totale     | DeepSeek-R1 671B       | cluster 8× H100                                                                                                             |

### Dépôts HuggingFace

| Variante               | Dépôt                                                                                                         |
| ---------------------- | ------------------------------------------------------------------------------------------------------------- |
| R1 complet             | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Distillation Llama-70B | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Distillation Qwen-32B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Distillation Qwen-14B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Distillation Llama-8B  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Distillation Qwen-7B   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Distillation Qwen-1.5B | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/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 avec Ollama

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

### Installer et exécuter

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

# Télécharger et exécuter (choisissez votre variante) :
ollama run deepseek-r1:1.5b    # En périphérie / tests
ollama run deepseek-r1:7b      # Petit budget — tient sur n’importe quel GPU 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 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,q sont des entiers avec 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 substituant : (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 √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. ∎
```

### Utiliser l’API compatible OpenAI

```bash
# Démarrer Ollama en tant que serveur (si ce n’est pas déjà en cours d’exécution)
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": "Factorisez complètement x^4 - 1 sur les entiers."}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Client Python (via le SDK OpenAI)

```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": "É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 meilleur débit pour le service multi-utilisateur grâce au batching continu, à PagedAttention et au cache de préfixe.

### GPU unique — 7B / 14B

```bash
pip install vllm

# 7B sur n’importe quel GPU 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é)

```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
```

> **Astuce :** Le checkpoint 32B Q4 GPTQ ou AWQ tient sur une seule RTX 4090 (24 Go) :
>
> ```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
```

### Interroger le point de terminaison vLLM

```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": "Résolvez : trouvez tous les nombres premiers p tels que p^2 + 2 soit aussi 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

```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(
    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>` des balises

```python
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

```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": "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`

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

# Télécharger et servir 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`

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

Déployer sur Clore.ai :

1. Ouvrez [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtrer par **2× GPU, 48 Go+ de VRAM au total** (par ex. 2× RTX 4090 ou A100 80 Go)
3. Définissez l’image Docker sur `vllm/vllm-openai:latest`
4. Mapper le port **8000** comme 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é passée

## Conseils pour les déploiements Clore.ai

### Choisir le bon GPU

| Budget        | GPU              | Coût journalier | Meilleure variante                 |
| ------------- | ---------------- | --------------- | ---------------------------------- |
| Minimal       | 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          |

### Réglage 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 le 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 standards à cause du `<think>` bloc :

| Complexité de la tâche              | Longueur de réflexion typique | Contexte total nécessaire |
| ----------------------------------- | ----------------------------- | ------------------------- |
| 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 عدة étapes  | \~4000–8000 jetons            | \~10000 jetons            |

## Dépannage

### Manque de mémoire (OOM)

```bash
# Réduisez 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 pas de `<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 prompt système :

```python
# Bien — 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": "..."}
]
```

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

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

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

### Premier jeton lent (TTFT élevé)

C’est normal — le modèle génère des `<think>` jetons avant la réponse visible. Pour les applications sensibles à la latence où le raisonnement n’est pas nécessaire, utilisez [DeepSeek-V3](/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.md) à 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 dans un volume persistant :

```bash
# 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

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

## Pour aller plus loin

* [Article DeepSeek-R1](https://arxiv.org/abs/2501.12948) — *Incitation à la capacité de raisonnement dans les LLM via l’apprentissage par renforcement*
* [GitHub DeepSeek-R1](https://github.com/deepseek-ai/DeepSeek-R1) — Dépôt officiel avec fiches modèle
* [Guide DeepSeek-V3](/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.md) — Modèle généraliste sans raisonnement du même laboratoire
* [Guide vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — Configuration complète pour le service en production
* [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — Déploiement local simple pour n’importe quel modèle
* [Guide Open WebUI](/guides/guides_v2-fr/modeles-de-langage/open-webui.md) — Interface de chat avec rendu natif `<think>` des balises
* [Guide Qwen 2.5](/guides/guides_v2-fr/modeles-de-langage/qwen25.md) — L’architecture de base utilisée par la plupart des distillations R1


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.