> 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, le modèle LLM open-source à la pointe avec des 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 [CLORE.AI Marketplace](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 en génération de code, raisonnement mathématique et résolution générale de problèmes. Voir le [journal des modifications](#whats-new-in-deepseek-v3-0324) pour les détails.
{% endhint %}

## Pourquoi DeepSeek-V3 ?

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

## Quoi de neuf dans 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 sur 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 preuves étape par étape
* 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 renforcées
* Meilleur pour les tâches de planification à étapes multiples
* Performance plus cohérente sur les cas limites et les invites ambiguës
* Meilleure conformité aux instructions pour les requêtes 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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

### Vérifiez 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 80Go** des GPU et un temps de téléchargement important. Une 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  | 16Go         | [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) |

## Exigences matérielles

### Précision complète

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

### Quantifié (AWQ/GPTQ)

| Modèle           | Quantification | VRAM    |
| ---------------- | -------------- | ------- |
| DeepSeek-V3-0324 | INT4           | 4x80GB  |
| DeepSeek-V2.5    | INT4           | 2x80 Go |
| 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
# Récupérer DeepSeek-V3 (nécessite des ressources importantes)
ollama pull deepseek-v3

# Ou 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="non-nécessaire"
)

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

### Streaming

```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 avec du 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 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 pour le code :

```python
prompt = """Écrivez une classe Python pour un arbre binaire de recherche avec :
- insertion
- recherche
- suppression
- parcours en ordre
Inclure 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 bas 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 d’usine d’application avec des blueprints pour :
- auth (connexion, inscription, déconnexion)
- api (endpoints REST)
- admin (tableau de bord)
Afficher 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
)
```

## Mathématiques et raisonnement

```python
# Problème mathématique 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 toutes les étapes clairement."""

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

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 (tokens/sec)

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

### Temps jusqu'au premier token (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      | 20Go         |
| DeepSeek-V2-Lite | INT4      | 10Go         |

## Benchmarks

### DeepSeek-V3-0324 vs 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 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}
    commande : >
      --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 80Go              | \~$2.00    |
| DeepSeek-V2.5            | 4x A100 80GB              | \~$1.00    |
| Développement/Test       | RTX 4090 (V2-Lite)        | \~$0.10    |
| API de production        | 8x H100 80GB              | \~$3.00    |

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

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

*Les prix varient selon le fournisseur. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** marché pour le développement (souvent 30-50 % moins cher)
* Payer 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 utiliser la quantification
--quantization awq

# Pour V2-Lite sur GPU 12GB
--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 ce drapeau pour les modèles DeepSeek
--trust-remote-code
```

### Multi-GPU ne fonctionne pas

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

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

## DeepSeek vs autres

| Fonction      | DeepSeek-V3-0324  | Llama 3.1 405B | Mixtral 8x22B     |
| ------------- | ----------------- | -------------- | ----------------- |
| Paramètres    | 671B (37B actifs) | 405B           | 176B (44B actifs) |
| Contexte      | 128K              | 128K           | 64K               |
| Code          | **Excellent**     | Excellent      | Bon               |
| Mathématiques | **Excellent**     | Bon            | Bon               |
| VRAM min      | 8x80GB            | 8x80GB         | 2x80 Go           |
| Licence       | MIT               | Llama 3.1      | Apache 2.0        |

**Utilisez DeepSeek-V3 lorsque :**

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

## Prochaines étapes

* [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
* [composant Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) - Déploiement plus simple
* [Affiner un 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.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.