> 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-v3.md).

# DeepSeek-V3

Exécutez DeepSeek-V3 avec un raisonnement exceptionnel sur les GPU Clore.ai

Exécutez DeepSeek-V3, le LLM open source de pointe aux capacités de raisonnement exceptionnelles sur les GPU CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Mis à jour : DeepSeek-V3-0324 (mars 2024)** — La dernière révision de DeepSeek-V3 apporte des améliorations significatives dans la génération de code, le raisonnement mathématique et la résolution générale de problèmes. Voir la [historique des modifications](#whats-new-in-deepseek-v3-0324) section pour plus de détails.
{% endhint %}

## Pourquoi DeepSeek-V3 ?

* **À la pointe de la technologie** - Rivalise avec GPT-4o et Claude 3.5 Sonnet
* **671B MoE** - 671B de paramètres au total, 37B actifs par token (inférence efficace)
* **Raisonnement amélioré** - DeepSeek-V3-0324 est nettement meilleur en maths et en code
* **Efficace** - L’architecture MoE réduit les coûts de calcul par rapport aux modèles denses
* **Code source ouvert** - Poids entièrement ouverts sous licence MIT
* **Contexte long** - Fenêtre de contexte de 128K tokens

## Nouveautés de DeepSeek-V3-0324

DeepSeek-V3-0324 (révision de mars 2024) introduit des améliorations significatives dans des domaines clés :

### Génération de code

* **+8-12 % sur HumanEval** par rapport au V3 original
* Meilleur pour les bases de code multi-fichiers et les tâches de refactorisation complexes
* Compréhension améliorée des frameworks modernes (FastAPI, Pydantic v2, LangChain v0.3)
* Plus fiable pour générer du code complet et exécutable sans omissions

### Raisonnement mathématique

* **+5 % sur MATH-500** benchmark
* Meilleure construction de démonstrations pas à pas
* Précision numérique améliorée pour les problèmes à étapes multiples
* Capacité renforcée à identifier et corriger les erreurs en cours de solution

### Raisonnement général

* Déduction logique et inférence causale plus solides
* Meilleur pour les tâches de planification à étapes multiples
* Performances plus constantes sur les cas limites et les invites ambiguës
* Meilleure conformité aux instructions sur les demandes complexes à contraintes multiples

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
vllm/vllm-openai:latest
```

**Ports :**

```
22/tcp
8000/http
```

**Commande (multi-GPU requis) :**

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V3-0324 \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 8 \
    --trust-remote-code
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

### Vérifier que cela fonctionne

```bash
# Vérifier si le service est prêt
curl https://your-http-pub.clorecloud.net/health

# Lister les modèles disponibles
curl https://your-http-pub.clorecloud.net/v1/models

# Obtenir la version
curl https://your-http-pub.clorecloud.net/version
```

{% hint style="warning" %}
**Important :** DeepSeek-V3 nécessite **8x A100 80GB** GPU et un temps de téléchargement important. L’erreur HTTP 502 peut persister pendant 15 à 30 minutes pendant le téléchargement du modèle.
{% endhint %}

## Variantes de modèle

| Modèle            | Paramètres | Actif | VRAM requise | HuggingFace                                                                                             |
| ----------------- | ---------- | ----- | ------------ | ------------------------------------------------------------------------------------------------------- |
| DeepSeek-V3-0324  | 671B       | 37B   | 8x80GB       | [deepseek-ai/DeepSeek-V3-0324](https://huggingface.co/deepseek-ai/DeepSeek-V3-0324)                     |
| DeepSeek-V3       | 671B       | 37B   | 8x80GB       | [deepseek-ai/DeepSeek-V3](https://huggingface.co/deepseek-ai/DeepSeek-V3)                               |
| DeepSeek-V3-Base  | 671B       | 37B   | 8x80GB       | [deepseek-ai/DeepSeek-V3-Base](https://huggingface.co/deepseek-ai/DeepSeek-V3-Base)                     |
| DeepSeek-V2.5     | 236B       | 21B   | 4x80GB       | [deepseek-ai/DeepSeek-V2.5](https://huggingface.co/deepseek-ai/DeepSeek-V2.5)                           |
| DeepSeek-V2-Lite  | 16B        | 2.4B  | 16 Go        | [deepseek-ai/DeepSeek-V2-Lite](https://huggingface.co/deepseek-ai/DeepSeek-V2-Lite)                     |
| DeepSeek-Coder-V2 | 236B       | 21B   | 4x80GB       | [deepseek-ai/DeepSeek-Coder-V2-Instruct](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Instruct) |

## Configuration matérielle requise

{% 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 %}

### Précision complète

| Modèle           | Minimum        | Recommandé   |
| ---------------- | -------------- | ------------ |
| DeepSeek-V3-0324 | 8x A100 80GB   | 8x H100 80GB |
| DeepSeek-V2.5    | 4x A100 80 Go  | 4x H100 80GB |
| DeepSeek-V2-Lite | RTX 4090 24 Go | A100 40 Go   |

### Quantifié (AWQ/GPTQ)

| Modèle           | Quantification | VRAM   |
| ---------------- | -------------- | ------ |
| DeepSeek-V3-0324 | INT4           | 4x80GB |
| DeepSeek-V2.5    | INT4           | 2x80GB |
| DeepSeek-V2-Lite | INT4           | 8 Go   |

## Installation

### Utilisation de vLLM (recommandé)

```bash
pip install vllm==0.7.3

# DeepSeek-V3-0324 (dernier, 8 GPU)
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --trust-remote-code \\
    --host 0.0.0.0 \
    --port 8000

# V3 original (toujours disponible)
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \\
    --host 0.0.0.0 \
    --port 8000
```

### Utilisation de Transformers

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "deepseek-ai/DeepSeek-V3-0324"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [{"role": "user", "content": "Expliquez l’informatique quantique en termes simples."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Utilisation d’Ollama

```bash
# Télécharger DeepSeek-V3 (nécessite des ressources importantes)
ollama pull deepseek-v3

# Ou une variante plus légère
ollama pull deepseek-coder-v2:16b

# Exécuter
ollama run deepseek-v3
```

## Utilisation de l’API

### API compatible OpenAI (vLLM)

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant IA serviable."},
        {"role": "user", "content": "Écrivez une fonction Python pour trouver les nombres premiers."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)
```

### Flux continu

```python
stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "Expliquez l’apprentissage automatique"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-ai/DeepSeek-V3-0324",
        "messages": [
            {"role": "user", "content": "Quelle est la capitale de la France ?"}
        ],
        "temperature": 0.7
    }'
```

## DeepSeek-V2-Lite (GPU unique)

Pour les utilisateurs disposant d’un matériel limité :

```bash
# Utilisation de vLLM
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V2-Lite \
    --trust-remote-code \\
    --host 0.0.0.0

# Utilisation d'Ollama
ollama run deepseek-coder-v2:16b
```

```python
# Utilisation de Transformers sur un GPU unique
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V2-Lite",
    torch_dtype=torch.float16,
    device_map="cuda",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2-Lite", trust_remote_code=True)
```

## Génération de code

DeepSeek-V3-0324 est le meilleur de sa catégorie pour le code :

```python
prompt = """Écrivez une classe Python pour un arbre binaire de recherche avec :
- insertion
- recherche
- suppression
- parcours infixe
Incluez des annotations de type et des docstrings."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2  # Plus faible pour le code
)

print(response.choices[0].message.content)
```

Tâches de code avancées où V3-0324 excelle :

```python
# Refactorisation multi-fichiers
prompt = """J’ai une application Flask avec tout le code dans app.py (500 lignes).
Refactorez-la pour utiliser le pattern factory d’application avec des blueprints pour :
- auth (connexion, inscription, déconnexion)
- api (points de terminaison REST)
- admin (tableau de bord)
Montrez la structure complète des fichiers et tous les fichiers."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
    max_tokens=4000
)
```

## Maths et raisonnement

```python
# Problème de maths complexe
prompt = """Prouvez que pour tout entier n >= 1, la somme 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6.
Utilisez l’induction mathématique et montrez clairement toutes les étapes."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # Très faible pour les maths
)

print(response.choices[0].message.content)
```

## Configuration multi-GPU

### 8x GPU (modèle complet — V3-0324)

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \
    --trust-remote-code
```

### 4x GPU (V2.5)

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V2.5 \
    --tensor-parallel-size 4 \
    --max-model-len 16384 \\
    --trust-remote-code
```

## Performances

### Débit (jetons/sec)

| Modèle                | GPU           | Contexte | Jetons/s |
| --------------------- | ------------- | -------- | -------- |
| DeepSeek-V3-0324      | 8x H100       | 32K      | \~85     |
| DeepSeek-V3-0324      | 8x A100 80GB  | 32K      | \~52     |
| DeepSeek-V3-0324 INT4 | 4x A100 80 Go | 16K      | \~38     |
| DeepSeek-V2.5         | 4x A100 80 Go | 16K      | \~70     |
| DeepSeek-V2.5         | 2x A100 80GB  | 8K       | \~45     |
| DeepSeek-V2-Lite      | RTX 4090      | 8K       | \~40     |
| DeepSeek-V2-Lite      | RTX 3090      | 4K       | \~25     |

### Temps jusqu'au premier jeton (TTFT)

| Modèle           | Configuration | TTFT     |
| ---------------- | ------------- | -------- |
| DeepSeek-V3-0324 | 8x H100       | \~750ms  |
| DeepSeek-V3-0324 | 8x A100       | \~1100ms |
| DeepSeek-V2.5    | 4x A100       | \~500ms  |
| DeepSeek-V2-Lite | RTX 4090      | \~150ms  |

### Utilisation mémoire

| Modèle           | Précision | VRAM requise |
| ---------------- | --------- | ------------ |
| DeepSeek-V3-0324 | FP16      | 8x 80GB      |
| DeepSeek-V3-0324 | INT4      | 4x 80GB      |
| DeepSeek-V2.5    | FP16      | 4x 80GB      |
| DeepSeek-V2.5    | INT4      | 2x 80GB      |
| DeepSeek-V2-Lite | FP16      | 20 Go        |
| DeepSeek-V2-Lite | INT4      | 10GB         |

## Benchmarks

### DeepSeek-V3-0324 vs la concurrence

| Benchmark             | V3-0324 | V3 (original) | GPT-4o | Claude 3.5 Sonnet |
| --------------------- | ------- | ------------- | ------ | ----------------- |
| MMLU                  | 88.5%   | 87.1%         | 88.7%  | 88.3%             |
| HumanEval             | 90.2%   | 82.6%         | 90.2%  | 92.0%             |
| MATH-500              | 67.1%   | 61.6%         | 76.6%  | 71.1%             |
| GSM8K                 | 92.1%   | 89.3%         | 95.8%  | 96.4%             |
| LiveCodeBench         | 72.4%   | 65.9%         | 71.3%  | 73.8%             |
| Classement Codeforces | 1850    | 1720          | 1780   | 1790              |

*Remarque : l’amélioration de MATH-500 de V3 → V3-0324 est de +5,5 points de pourcentage.*

## Docker Compose

```yaml
version: '3.8'

services:
  deepseek:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment :
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: >
      --model deepseek-ai/DeepSeek-V2-Lite
      --host 0.0.0.0
      --port 8000
      --trust-remote-code
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## Résumé des exigences GPU

| Cas d’utilisation        | Configuration recommandée | Coût/heure |
| ------------------------ | ------------------------- | ---------- |
| DeepSeek-V3-0324 complet | 8x A100 80GB              | \~$2.00    |
| DeepSeek-V2.5            | 4x A100 80 Go             | \~$1.00    |
| Développement/Test       | RTX 4090 (V2-Lite)        | \~$0.10    |
| API de production        | 8x H100 80GB              | \~$3.00    |

## Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

| Configuration GPU | Tarif horaire | Tarif journalier |
| ----------------- | ------------- | ---------------- |
| RTX 4090 24 Go    | \~$0.10       | \~$2.30          |
| A100 40 Go        | \~$0.17       | \~$4.00          |
| A100 80 Go        | \~$0.25       | \~$6.00          |
| 4x A100 80 Go     | \~$1.00       | \~$24.00         |
| 8x A100 80GB      | \~$2.00       | \~$48.00         |

*Les prix varient selon le fournisseur. Consultez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour le développement — environ un tiers des serveurs sont proposés en spot sous le prix à la demande (médiane \~13 % de remise), le reste s’aligne dessus
* Payez avec **CLORE** jetons
* Utilisez DeepSeek-V2-Lite pour les tests avant de monter en charge

## Dépannage

### Mémoire insuffisante

```bash
# Réduire la longueur du contexte
--max-model-len 8192

# Ou utilisez la quantification
--quantization awq

# Pour V2-Lite sur un GPU de 12 Go
--gpu-memory-utilization 0.85
--max-model-len 4096
```

### Téléchargement du modèle lent

```bash
# Pré-téléchargement
huggingface-cli download deepseek-ai/DeepSeek-V3-0324

# Ou utilisez un miroir
export HF_ENDPOINT=https://hf-mirror.com
```

### Erreur trust\_remote\_code

```bash
# Incluez toujours cet indicateur pour les modèles DeepSeek
--trust-remote-code
```

### Le multi-GPU ne fonctionne pas

```bash
# Vérifiez NCCL
nvidia-smi topo -m

# Définissez les variables NCCL
export NCCL_DEBUG=INFO
export NCCL_P2P_DISABLE=0
```

## DeepSeek vs les autres

| Fonctionnalité | DeepSeek-V3-0324  | Llama 3.1 405B | Mixtral 8x22B     |
| -------------- | ----------------- | -------------- | ----------------- |
| Paramètres     | 671B (37B actifs) | 405B           | 176B (44B actifs) |
| Contexte       | 128K              | 128K           | 64K               |
| Code           | **Excellente**    | Excellent      | Bon               |
| Maths          | **Excellente**    | Bon            | Bon               |
| VRAM minimale  | 8x80GB            | 8x80GB         | 2x80GB            |
| Licence        | MIT               | Llama 3.1      | Apache 2.0        |

**Utilisez DeepSeek-V3 lorsque :**

* La meilleure performance de raisonnement est nécessaire
* La génération de code est l’usage principal
* Les tâches de maths/logique sont importantes
* Vous disposez d’une configuration multi-GPU
* Vous voulez des poids entièrement open source (licence MIT)

## Étapes suivantes

* [vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) - Serveur de déploiement
* [DeepSeek-R1](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md) - Variante spécialisée en raisonnement
* [DeepSeek Coder](/guides/guides_v2-fr/modeles-de-langage/deepseek-coder.md) - Variante spécifique au code
* [Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Déploiement plus simple
* [Ajustement fin de LLM](/guides/guides_v2-fr/entrainement/finetune-llm.md) - Entraînement personnalisé


---

# 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-v3.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.