DeepSeek-V3

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

Exécutez DeepSeek-V3, le modèle LLM open-source à la pointe avec des 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 CLORE.AI Marketplace.

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 pour les détails.

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

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

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

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	16Go	deepseek-ai/DeepSeek-V2-Lite
DeepSeek-Coder-V2	236B	21B	4x80GB	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é)

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

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

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

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 avec du 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 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 :

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 :

# 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

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

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

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

# 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

# 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 ce drapeau pour les modèles DeepSeek
--trust-remote-code

Multi-GPU ne fonctionne pas

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

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

• DeepSeek Coder - Variante spécifique au code

• composant Ollama - Déploiement plus simple

• Affiner un LLM - Entraînement personnalisé