# Modèle de raisonnement DeepSeek-R1

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

## 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](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Distill Llama-70B | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Distill Qwen-32B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Distill Qwen-14B  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Distill Llama-8B  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Distill Qwen-7B   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Distill 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 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

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

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

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

```bash
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é)

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

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

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

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

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

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

### Ollama Docker (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

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

```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:-}
    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](https://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)

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

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

```python
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](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/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 :

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

# 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](https://arxiv.org/abs/2501.12948) — *Inciter la capacité de raisonnement dans les LLMs via l'apprentissage par renforcement*
* [DeepSeek-R1 GitHub](https://github.com/deepseek-ai/DeepSeek-R1) — Dépôt officiel avec fiches des modèles
* [Guide DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-v3) — Modèle généraliste non axé sur le raisonnement du même laboratoire
* [- Débit le plus élevé](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) — Configuration complète de service pour la production
* [Guide Ollama](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama) — Déploiement local simple pour n'importe quel modèle
* [Guide Open WebUI](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/open-webui) — Interface de chat avec rendu natif `<think>` de balises
* [Guide Qwen 2.5](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/qwen25) — L'architecture de base utilisée par la plupart des distills R1