# 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](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/vllm) - Serveur de déploiement
* [DeepSeek-R1](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-r1) - Variante spécialisée en raisonnement
* [DeepSeek Coder](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/deepseek-coder) - Variante spécifique au code
* [composant Ollama](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/ollama) - Déploiement plus simple
* [Affiner un LLM](https://docs.clore.ai/guides/guides_v2-fr/entrainement/finetune-llm) - Entraînement personnalisé