> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md).

# Modèle de raisonnement DeepSeek-R1

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

{% hint style="success" %}
Tous les exemples s'exécutent sur des serveurs GPU loués via le [la place de marché CLORE.AI](https://clore.ai/marketplace). Les instances RTX 4090 commencent à 0,14–0,42 $/h.
{% 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 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](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) (0,14–0,42 $/h)     |
| 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 pleine fidélité            | DeepSeek-R1 671B       | cluster de 8× H100                                                                                                          |

### Dépôts HuggingFace

| Variante           | Dépôt                                                                                                         |
| ------------------ | ------------------------------------------------------------------------------------------------------------- |
| R1 complet         | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Llama-70B distillé | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Qwen-32B distillé  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Qwen-14B distillé  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Llama-8B distillé  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Qwen-7B distillé   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Qwen-1,5B distillé | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## Exigences

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| 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

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

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

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

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

### Interrogez 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é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

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

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

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

```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éployez sur Clore.ai :

1. Ouvrez [clore.ai/marketplace](https://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)

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

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

```python
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](/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 à l’avance dans un volume persistant :

```bash
# 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](https://arxiv.org/abs/2501.12948) — *Inciter 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 de modèles
* [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 de 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 native `<think>` rendu 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
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.