Comment Exécuter DeepSeek-V4 Localement : Guide d’Installation Pro et Flash

Environ 9 min

Comment Exécuter DeepSeek-V4 Localement : Guide d’Installation Pro et Flash

DeepSeek-V4 est l’une des sorties de modèles open-weight les plus ambitieuses de DeepSeek à ce jour. La famille comprend DeepSeek-V4-Pro, un modèle Mixture-of-Experts (MoE) de 1,6T de paramètres avec 49 milliards de paramètres activés, et DeepSeek-V4-Flash, un modèle MoE plus petit de 284 milliards de paramètres avec 13 milliards de paramètres activés. Les deux modèles supportent une longueur de contexte allant jusqu’à un million de tokens.

Cette combinaison est prometteuse, mais soulève une question pratique : peut-on réellement exécuter DeepSeek-V4 localement ?

La réponse est oui, mais avec une mise en garde importante. DeepSeek-V4 n’est pas un modèle adapté à un ordinateur portable. Même la version Flash nécessite un déploiement multi-GPU sérieux. Ce guide détaille la procédure d’installation locale en utilisant les dépôts officiels DeepSeek sur Hugging Face, explique le matériel à prévoir, et montre comment utiliser correctement les fichiers d’inférence et d’encodage officiels.

Pages de référence des modèles :

DeepSeek-V4-Pro vs DeepSeek-V4-Flash

Avant de télécharger quoi que ce soit, choisissez la bonne variante du modèle.

Modèle	Paramètres Totaux	Paramètres Activés	Longueur de Contexte	Précision	Idéal Pour
DeepSeek-V4-Flash	284B	13B	1M	FP4 + FP8 mixte	Expériences locales rapides, service à moindre coût, assistants de codage, tests de contexte long
DeepSeek-V4-Pro	1,6T	49B	1M	FP4 + FP8 mixte	Qualité maximale, laboratoires de recherche, grands clusters GPU, tâches complexes de raisonnement et agentiques

Le détail le plus important est que DeepSeek-V4 utilise une architecture Mixture-of-Experts (MoE). Seule une partie du modèle est activée pour chaque token, ce qui réduit le coût de calcul. Cependant, il faut toujours stocker et charger les poids du modèle. Cela signifie que les besoins en mémoire GPU et en stockage restent très élevés.

Pour la plupart des développeurs, DeepSeek-V4-Flash est le point de départ réaliste. DeepSeek-V4-Pro est mieux considéré comme un déploiement à l’échelle d’un cluster.

Qu’est-ce qui Rend DeepSeek-V4 Différent ?

Selon la fiche technique de DeepSeek, la série V4 introduit plusieurs améliorations majeures :

Architecture d’Attention Hybride : DeepSeek combine Compressed Sparse Attention (CSA) et Heavily Compressed Attention (HCA) pour améliorer l’efficacité sur de longs contextes. Dans le cadre du million de tokens, DeepSeek-V4-Pro utilise apparemment beaucoup moins de cache KV que DeepSeek-V3.2.
Hyper-Connexions Contraintes par Variété (mHC) : Cela améliore la stabilité sur des réseaux très profonds tout en préservant la capacité du modèle.
Optimiseur Muon : DeepSeek utilise Muon pendant l’entraînement pour une meilleure convergence et stabilité.
Long Contexte : Pro et Flash supportent jusqu’à 1M tokens, avec une recommandation DeepSeek d’au moins 384K tokens de contexte pour le mode Think Max.
Multiples Modes de Raisonnement : DeepSeek-V4 supporte les usages Non-think, Think High et Think Max.

Pour le déploiement local, les deux changements pratiques les plus importants sont la précision mixte FP4/FP8 et le format d’encodage de chat personnalisé.

Exigences Matérielles

DeepSeek-V4 n’est pas conçu pour les GPU grand public comme le RTX 4090, sauf si vous expérimentez uniquement avec des quantifications communautaires fortement modifiées à l’avenir. Pour les poids officiels, prévoyez des GPU serveur.

Planification Matérielle Pratique

Cas d’Usage	Matériel Suggéré	Remarques
Déploiement test DeepSeek-V4-Flash	4-8 GPU NVIDIA à haute mémoire	Les GPU de classe H100/H200/A100 sont la cible pratique
Service en production DeepSeek-V4-Flash	8+ GPU à haute mémoire	Plus de GPU améliorent le débit et les charges longues de contexte
Déploiement recherche DeepSeek-V4-Pro	Grand cluster multi-nœuds GPU	Considérez cela comme une infrastructure cluster, pas un modèle pour poste de travail unique
Think Max avec long contexte	Mémoire GPU supplémentaire et budget cache KV	DeepSeek recommande au moins 384K tokens de contexte pour Think Max

Exigences de Stockage

Prévoyez un stockage local important avant de commencer le téléchargement :

Utilisez un stockage NVMe SSD autant que possible.
Gardez de l’espace supplémentaire pour les poids convertis.
Évitez de télécharger directement sur un disque système de petite taille.
Attendez-vous à ce que le modèle Pro nécessite beaucoup plus de stockage que Flash.

Une organisation sûre est :

/data/models/deepseek-v4-flash-hf      # fichiers originaux Hugging Face
/data/models/deepseek-v4-flash-infer   # poids convertis pour l’inférence
/data/cache/huggingface                # cache HF

Si vous louez un serveur GPU cloud, choisissez une instance avec NVMe local ou attachez un volume rapide et volumineux. Pour un déploiement de type VPS, vous pouvez comparer les serveurs GPU ou à haute mémoire via des fournisseurs comme LightNode, mais assurez-vous que l’instance dispose bien de la mémoire GPU requise pour ce type de modèle.

Exigences Logicielles

Vous avez besoin d’un environnement Linux avec des pilotes NVIDIA récents et CUDA.

Configuration recommandée :

Composant	Recommandation
OS	Ubuntu 22.04 ou plus récent
Python	3.10+
Pilote GPU	Pilote NVIDIA data center récent
CUDA	CUDA 12.x de préférence
PyTorch	Build avec support CUDA
Git LFS	Requis pour les fichiers modèles
Hugging Face CLI	Requis pour des téléchargements fiables

Installez les outils de base :

sudo apt update
sudo apt install -y git git-lfs python3 python3-venv python3-pip

git lfs install
pip install -U huggingface_hub

Si vous utilisez un environnement virtuel Python :

python3 -m venv dsv4-env
source dsv4-env/bin/activate
pip install -U pip wheel setuptools
pip install -U huggingface_hub torch transformers safetensors

Étape 1 : Télécharger DeepSeek-V4-Flash

Pour la plupart des utilisateurs, commencez par Flash :

mkdir -p /data/models
cd /data/models

huggingface-cli download deepseek-ai/DeepSeek-V4-Flash \
  --local-dir DeepSeek-V4-Flash \
  --local-dir-use-symlinks False

Si vous préférez le modèle Pro :

huggingface-cli download deepseek-ai/DeepSeek-V4-Pro \
  --local-dir DeepSeek-V4-Pro \
  --local-dir-use-symlinks False

Si le téléchargement est interrompu, relancez simplement la même commande. Hugging Face reprendra le téléchargement.

Étape 2 : Inspecter la Structure Officielle du Dépôt

Après téléchargement, vérifiez le dossier du modèle :

cd /data/models/DeepSeek-V4-Flash
ls

La fiche technique pointe vers deux dossiers importants :

inference/ - code officiel d’inférence locale, incluant la conversion des poids et les scripts de génération
encoding/ - utilitaires d’encodage de prompt et de parsing de sortie pour DeepSeek-V4

C’est important car DeepSeek-V4 ne fournit pas de template de chat au format Jinja classique. Il ne faut pas supposer que chaque wrapper de chat compatible OpenAI formatera correctement les prompts par défaut.

Étape 3 : Convertir les Poids pour l’Inférence Officielle

Le README officiel d’inférence utilise une étape de conversion avant la génération.

Depuis le dépôt du modèle :

cd /data/models/DeepSeek-V4-Flash/inference

export HF_CKPT_PATH=/data/models/DeepSeek-V4-Flash
export SAVE_PATH=/data/models/DeepSeek-V4-Flash-infer
export EXPERTS=256
export MP=4
export CONFIG=config.json

python convert.py \
  --hf-ckpt-path ${HF_CKPT_PATH} \
  --save-path ${SAVE_PATH} \
  --n-experts ${EXPERTS} \
  --model-parallel ${MP}

Notes sur les paramètres :

Variable	Signification
`HF_CKPT_PATH`	Chemin vers les fichiers originaux Hugging Face
`SAVE_PATH`	Chemin de sortie pour les poids convertis d’inférence
`EXPERTS=256`	Nombre d’experts utilisés par la conversion d’inférence DeepSeek-V4
`MP=4`	Taille du parallélisme de modèle ; généralement égale au nombre de GPU utilisés
`CONFIG`	Fichier de configuration du modèle utilisé par le script de génération

Si vous utilisez plus de GPU, ajustez MP en conséquence. Par exemple, sur un nœud à 8 GPU :

export MP=8

Option Expert FP8

Le README officiel d’inférence indique que si vous souhaitez utiliser des experts FP8 au lieu de FP4, supprimez cette ligne dans config.json :

"expert_dtype": "fp4"

Puis passez --expert-dtype fp8 lors de la conversion :

python convert.py \
  --hf-ckpt-path ${HF_CKPT_PATH} \
  --save-path ${SAVE_PATH} \
  --n-experts ${EXPERTS} \
  --model-parallel ${MP} \
  --expert-dtype fp8

Pour la plupart des utilisateurs, commencez d’abord avec la configuration mixte FP4/FP8 par défaut. Changez la précision seulement après avoir une base fonctionnelle.

Étape 4 : Démarrer un Chat Interactif

Une fois la conversion terminée, lancez le script officiel de génération :

cd /data/models/DeepSeek-V4-Flash/inference

export MP=4
export SAVE_PATH=/data/models/DeepSeek-V4-Flash-infer
export CONFIG=config.json

torchrun --nproc-per-node ${MP} generate.py \
  --ckpt-path ${SAVE_PATH} \
  --config ${CONFIG} \
  --interactive

Pour un fichier d’entrée batch :

torchrun --nproc-per-node ${MP} generate.py \
  --ckpt-path ${SAVE_PATH} \
  --config ${CONFIG} \
  --input-file prompts.txt

Pour un run multi-nœuds :

torchrun \
  --nnodes ${NODES} \
  --nproc-per-node $((MP / NODES)) \
  --node-rank $RANK \
  --master-addr $ADDR \
  generate.py \
  --ckpt-path ${SAVE_PATH} \
  --config ${CONFIG} \
  --input-file prompts.txt

Assurez-vous que chaque nœud peut accéder au chemin du checkpoint converti, ou copiez les fichiers convertis au même emplacement sur chaque machine.

Étape 5 : Utiliser les Bons Paramètres d’Échantillonnage

DeepSeek recommande les paramètres d’échantillonnage suivants pour un déploiement local :

temperature = 1.0
top_p = 1.0

Si votre script de génération expose ces paramètres en ligne de commande, utilisez-les directement. Sinon, définissez-les dans le script ou la config où les paramètres d’échantillonnage sont définis.

Pour le mode Think Max, DeepSeek recommande une fenêtre de contexte d’au moins :

384K tokens

Ne commencez pas avec une fenêtre de contexte énorme lors de votre premier test. Commencez petit, confirmez que le modèle se charge et génère correctement, puis augmentez progressivement la longueur du contexte en surveillant la mémoire GPU.

Étape 6 : Comprendre l’Encodage de Chat DeepSeek-V4

DeepSeek-V4 n’inclut pas de template de chat Jinja standard. Le dépôt fournit à la place un dossier encoding/ avec des utilitaires Python.

L’usage de base ressemble à ceci :

from encoding_dsv4 import encode_messages, parse_message_from_completion_text

messages = [
    {"role": "system", "content": "Vous êtes un assistant utile."},
    {"role": "user", "content": "Combien font 2+2 ?"},
]

prompt = encode_messages(messages, thinking_mode="thinking")
print(prompt)

Pour un chat sans réflexion, utilisez le mode chat :

prompt = encode_messages(messages, thinking_mode="chat")

Pour le mode réflexion, le modèle utilise des délimiteurs explicites de raisonnement :

<think> ... </think>

Le parseur peut convertir le texte généré en messages structurés d’assistant :

completion = "Simple arithmetic.</think>2 + 2 = 4.<｜end▁of▁sentence｜>"
parsed = parse_message_from_completion_text(completion, thinking_mode="thinking")
print(parsed)

C’est particulièrement important si vous souhaitez construire votre propre wrapper API local autour de DeepSeek-V4.

Explication des Modes de Raisonnement

DeepSeek-V4 supporte trois styles pratiques de raisonnement :

Mode	Comportement	Cas d’Usage
Non-think	Réponses rapides et directes	Q&R simples, résumé, aide au codage de routine
Think High	Réponses raisonnées avec analyse délibérée	Débogage, planification, mathématiques, décisions d’architecture
Think Max	Effort maximal de raisonnement	Tâches de codage complexes, workflows agentiques, résolution de problèmes de niveau recherche

Pour un serveur local, vous pouvez exposer ces modes comme des noms de modèles séparés, par exemple :

deepseek-v4-flash-chat
deepseek-v4-flash-thinking
deepseek-v4-flash-max

En interne, chaque route peut utiliser un encodage de prompt différent, des limites de contexte et des paramètres de génération distincts.

Peut-on Exécuter DeepSeek-V4 avec vLLM ou SGLang ?

Au lancement, la voie la plus sûre est le code d’inférence officiel DeepSeek dans le dépôt modèle. Les frameworks de service génériques peuvent nécessiter des mises à jour avant de supporter pleinement l’architecture DeepSeek-V4, la précision mixte, le comportement long-contexte et l’encodage personnalisé.

Une approche pratique est :

D’abord, exécutez avec succès le chemin officiel inference/generate.py.
Confirmez la qualité de sortie et le formatage des prompts avec les utilitaires officiels encoding/.
Puis vérifiez si votre framework préféré a ajouté un support explicite pour DeepSeek-V4.
Ne migrez vers vLLM, SGLang, TensorRT-LLM ou un autre framework de service qu’après confirmation du support.

Cela évite un échec fréquent : le modèle se charge, mais la qualité du chat est mauvaise car le template de prompt est incorrect.

Construire un Wrapper API Local Simple

Si vous souhaitez un endpoint local de type OpenAI, vous pouvez envelopper le chemin officiel de génération avec FastAPI. L’implémentation exacte dépend de votre intégration de generate.py, mais le flux général est :

Recevoir des messages compatibles OpenAI.
Les convertir avec encoding_dsv4.encode_messages().
Envoyer le prompt encodé au moteur d’inférence DeepSeek-V4.
Parser la sortie avec parse_message_from_completion_text().
Retourner une réponse JSON compatible OpenAI.

Pseudo-code :

from encoding_dsv4 import encode_messages, parse_message_from_completion_text

messages = [
    {"role": "system", "content": "Vous êtes un assistant utile."},
    {"role": "user", "content": "Expliquez le cache KV en termes simples."},
]

prompt = encode_messages(messages, thinking_mode="thinking")

# Envoyer le prompt à votre worker local DeepSeek-V4
raw_completion = run_deepseek_v4(prompt)

assistant_message = parse_message_from_completion_text(
    raw_completion,
    thinking_mode="thinking",
)

print(assistant_message["content"])

Pour la production, ajoutez :

mise en file d’attente des requêtes
sortie en streaming
gestion des timeout
vérifications de santé GPU
application de la limite de contexte max
logs structurés
authentification

Dépannage

1. CUDA Out of Memory

Réduisez la pression mémoire en :

diminuant la longueur du contexte
réduisant la taille du batch
augmentant la taille du parallélisme tensoriel/modèle
utilisant plus de GPU
commençant par DeepSeek-V4-Flash plutôt que Pro

Le long contexte est généralement la première chose à réduire lors du débogage.

2. Échec ou Blocage du Téléchargement

Utilisez huggingface-cli download plutôt que le téléchargement via navigateur. Relancez la même commande pour reprendre.

Vous pouvez aussi définir un répertoire cache dédié :

export HF_HOME=/data/cache/huggingface
export HUGGINGFACE_HUB_CACHE=/data/cache/huggingface/hub

3. Le Modèle Génère des Réponses de Chat Bizarres

Vérifiez le formatage du prompt. DeepSeek-V4 n’utilise pas de template de chat Jinja standard. Utilisez l’implémentation officielle encoding/.

4. Échec d’Exécution Multi-GPU

Vérifiez que PyTorch détecte tous les GPU :

python - <<'PY'
import torch
print(torch.cuda.device_count())
for i in range(torch.cuda.device_count()):
    print(i, torch.cuda.get_device_name(i))
PY

Vérifiez aussi le réseau NCCL pour les runs multi-nœuds :

export NCCL_DEBUG=INFO

5. Think Max Est Trop Lent

Think Max est conçu pour consacrer plus de calcul au raisonnement difficile. Utilisez-le uniquement pour les tâches qui justifient ce coût. Pour un usage assistant normal, Non-think ou Think High sont généralement plus pratiques.

Stratégie de Déploiement Recommandée

Si vous déployez DeepSeek-V4 localement pour la première fois, suivez cette séquence :

Commencez par DeepSeek-V4-Flash.
Utilisez le code d’inférence officiel.
Testez d’abord avec un contexte réduit.
Confirmez que l’encodage officiel fonctionne.
Augmentez progressivement la longueur du contexte.
Ajoutez un wrapper API seulement après que la génération locale soit stable.
Envisagez Pro uniquement si vous disposez de ressources GPU à l’échelle cluster.

Dernières Remarques

DeepSeek-V4 est puissant, mais ce n’est pas un modèle local à usage occasionnel. La version Flash est le point d’entrée pratique, tandis que Pro appartient aux environnements multi-GPU ou multi-nœuds sérieux. La clé d’une installation réussie est de respecter le workflow officiel : télécharger le dépôt Hugging Face, convertir les poids avec les outils d’inférence fournis, lancer la génération avec torchrun, et utiliser les utilitaires d’encodage dédiés DeepSeek-V4 au lieu de supposer un template de chat générique.

Si vous avez seulement besoin d’expérimenter avec des prompts, le service de chat hébergé DeepSeek ou les routes API peuvent être plus simples. Mais si vous avez besoin de confidentialité des données, de contrôle total, sans facturation par token, ou d’une infrastructure personnalisée, exécuter DeepSeek-V4 localement vous offre une base solide pour construire des systèmes IA privés à long contexte.