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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

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 section pour plus de détails.

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

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

# 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

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.

Variantes de modèle

Modèle	Paramètres	Actif	VRAM requise	HuggingFace
DeepSeek-V3-0324	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3-0324
DeepSeek-V3	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3
DeepSeek-V3-Base	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3-Base
DeepSeek-V2.5	236B	21B	4x80GB	deepseek-ai/DeepSeek-V2.5
DeepSeek-V2-Lite	16B	2.4B	16 Go	deepseek-ai/DeepSeek-V2-Lite
DeepSeek-Coder-V2	236B	21B	4x80GB	deepseek-ai/DeepSeek-Coder-V2-Instruct

Configuration matérielle requise

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 sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

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

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

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

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

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

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

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é :

# 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

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

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 :

# 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

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

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)

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

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

# 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

# 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

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

Le multi-GPU ne fonctionne pas

# 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 - Serveur de déploiement

• DeepSeek-R1 - Variante spécialisée en raisonnement

• DeepSeek Coder - Variante spécifique au code

• Ollama - Déploiement plus simple

• Ajustement fin de LLM - Entraînement personnalisé