DeepSeek-V3.1 est un modèle de chat hybride Mixture-of-Experts (MoE) publié par DeepSeek en août 2025 qui prend en charge deux modes d'inférence — un mode rapide « non-réflexion » et un mode « réflexion » délibéré — depuis le même point de contrôle. Le modèle est disponible sur Hugging Face et peut être exécuté localement via plusieurs chemins (vLLM, Ollama/llama.cpp, GGUF de type Ollama ou configurations multi-GPU à grande échelle). Je vous présente ci-dessous les prérequis, le fonctionnement du mode réflexion, plusieurs options d'exécution locale (avec des extraits de code exécutables) et une recette de déploiement en mode réflexion étape par étape, avec des exemples d'appel d'outils et de modèles de jetons.
Qu'est-ce que DeepSeek-V3.1 et pourquoi est-ce important ?
DeepSeek-V3.1 est la mise à jour de la famille v3 de DeepSeek qui introduit un conception d'inférence hybride: le même modèle peut être exécuté dans thinking (délibératif, en plusieurs étapes) ou non-pensée (réponse directe, plus rapide) en modifiant le modèle de chat. Architecturalement, il s'agit d'une vaste famille de MoE (point de contrôle de base : environ 671 milliards de paramètres au total, environ 37 milliards activés par jeton) avec un entraînement en contexte long étendu à 128 8 jetons et la prise en charge de la micro-scalabilité FP3.1. DeepSeek a positionné la version 1 comme une version prête pour les agents : un meilleur appel d'outils, des compétences d'agent améliorées et une plus grande efficacité de réflexion par rapport aux versions R2025 précédentes. Annoncée en août XNUMX, cette version a été intégrée à Hugging Face, aux outils CFD/OSS et aux guides de déploiement cloud.
Comment fonctionne le modèle hybride (concis)
- Un point de contrôle, deux modèles : Les modes Pensée et Non-Pensée sont contrôlés par le modèle de chat et
<think>/</think>Convention de jeton dans l'invite. La fiche modèle détaille les préfixes exacts. - Améliorations de l'agent/de l'outil : Les améliorations post-formation permettent des appels d'outils plus intelligents : le modèle attend un format JSON d'appel d'outil strict pour une exécution d'outil sûre et déterministe.
- Compromis de performance : Le mode de réflexion utilise des jetons pour le raisonnement interne de type chaîne de pensée et peut être plus lent/consommateur de jetons ; le mode sans réflexion est plus rapide et moins coûteux. Les benchmarks de la carte modèle montrent des améliorations substantielles pour le raisonnement et le code de la version 3.1.
Comment le modèle est structuré
- dorsale du MoE: grand nombre total de paramètres avec un sous-ensemble activé plus petit par jeton (inférence économique).
- Formation en contexte long: V3.1 étend considérablement les phases de contexte long (32 k → formation plus importante sur les documents longs) pour prendre en charge plus de 128 K fenêtres dans certaines versions.
- Flux de travail natif FP8: DeepSeek utilise largement les formats FP8 (w8a8 / UE8M0) pour l'efficacité du poids/de l'activation ; des scripts de conversion communautaires existent si vous préférez BF16/FP16.
Quelles sont les exigences pour exécuter DeepSeek-V3.1 localement ? (Matériel, stockage et logiciel)
Exécuter le plein Le modèle V3.1 (non quantifié) représente un projet de grande envergure. Vous trouverez ci-dessous des catégories réalistes de configurations et leurs exigences habituelles.
Seaux pratiques
- Cluster / laboratoire de recherche (modèle complet): plusieurs GPU à haute mémoire (classe H100/H800 ou plusieurs GPU Ada/Hopper), multi-nœuds avec des dizaines de GPU, beaucoup de stockage NVMe (des centaines de Go) et des frameworks d'inférence spécialisés (SGLang, vLLM, LMDeploy, TRT-LLM).
- Serveur unique haut de gamme (quantifié): possible avec une quantification lourde (INT4/AWQ/AWQ2/gguf) et des frameworks comme Ollama (pré-emballé) ou des GGUF communautaires — nécessite toujours des dizaines à des centaines de Go de RAM GPU ou un déchargement intelligent du CPU + GPU.
- Ordinateur portable de développement / boîtier de développement: non réalisable pour le modèle complet ; utilisez de petites variantes distillées/affinées ou connectez-vous au serveur local/à l'instance Ollama.
Liste de contrôle du matériel (pratique)
- GPUPour un débit d'inférence réel de la version 3.1 complète : clusters multi-GPU (H100 / H800 / Ada Lovelace+). Pour l'exécution FP8, des GPU avec capacité de calcul et prise en charge des pilotes sont nécessaires.
- RAM et stockage: Prévoyez des centaines de Go d'espace disque disponible pour les fichiers modèles (les pages modèles indiquent quelques centaines de Go selon le format/la quantification), ainsi que de l'espace de travail pour les formats convertis. Les métadonnées Ollama indiquent une empreinte d'environ 400 Go pour un package Ollama DeepSeek V3.1 dans la bibliothèque.
- Réseau:Pour l'inférence multi-nœuds, vous avez besoin d'interconnexions à faible latence (NVLink / InfiniBand) et d'outils d'orchestration pour les configurations parallèles aux tenseurs.
Liste de contrôle des logiciels
- OS:Linux est recommandé pour les outils d'inférence communautaires (la démo DeepSeek-Infer répertorie Linux/Python).
- Python: 3.10+ (dans de nombreux exemples DeepSeek). Les versions typiques des packages sont épinglées dans le dépôt.
requirements.txt. - Cadres et outils (Choisissez-en un ou plusieurs) : SGLang, vLLM, LMDeploy, TRT-LLM/TensorRT-LLM, LightLLM ou Ollama pour des installations locales plus simples. Chacun dispose d'instructions et d'une prise en charge de précision/quantification différente.
Note pratique : Si vous n'avez qu'un seul GPU grand public (par exemple, 24 à 48 Go), vous utiliserez probablement des GGUF quantifiés ou une inférence à distance ; si vous avez une station de travail avec > 128 Go de RAM plus un cluster GPU de classe H100/H200, vous pouvez cibler une inférence FP8/FP16 de plus haute fidélité avec vLLM.
Comment exécuter DeepSeek-V3.1 localement ?
Vous trouverez ci-dessous plusieurs chemins pratiques que vous pouvez utiliser, du chemin le plus manuel/flexible au chemin le plus simple pour une seule boîte de développement. Je fournirai des tutoriels étape par étape et des exemples de code.
Option A — Démo officielle de DeepSeek-Infer (développement/chemin de cluster)
Ceci est l'exemple/la démonstration du dépôt pour l'inférence FP8/BF16. Utilisez-le si vous prévoyez une architecture multi-nœuds ou souhaitez expérimenter le code d'inférence officiel.
- Cloner, préparer l'environnement
git clone https://github.com/deepseek-ai/DeepSeek-V3.git
cd DeepSeek-V3/inference
# Create a dedicated venv / conda env
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
(Repo inference/requirements.txt (liste les versions épinglées de torch/triton/transformers recommandées par l'équipe.)
- Télécharger les poids du modèle
- Télécharger depuis la page du modèle Hugging Face (
deepseek-ai/DeepSeek-V3.1) et les placer sous/path/to/DeepSeek-V3. La carte modèle et la note de dépôt contiennent toutes deux des liens de stockage officiels de Hugging Face.
- Convertir les poids pour la démonstration
# example conversion command shown in the repo
python convert.py --hf-ckpt-path /path/to/DeepSeek-V3 --save-path /path/to/DeepSeek-V3-Demo --n-experts 256 --model-parallel 16
- Exécuter une génération interactive (distribuée)
torchrun --nnodes 2 --nproc-per-node 8 --node-rank $RANK --master-addr $ADDR \
generate.py --ckpt-path /path/to/DeepSeek-V3-Demo --config configs/config_671B.json \
--interactive --temperature 0.7 --max-new-tokens 200
Il s'agit de l'exemple canonique du référentiel DeepSeek pour les exécutions de type cluster.
Option B — vLLM (recommandé pour les déploiements de serveurs et API compatible OpenAI)
vLLM prend en charge DeepSeek en modes FP8/BF16 et vous offre un serveur compatible OpenAI. C'est une solution de production populaire pour les modèles volumineux en raison de ses optimisations mémoire et de sa compatibilité API.
Démarrez un serveur vLLM qui récupérera le modèle de Hugging Face (exemple de modèle) :
# this will download/serve the model (replace with exact model id if needed)
vllm serve deepseek-ai/DeepSeek-V3.1 --host 0.0.0.0 --port 8000
Demandez ensuite les complétions avec curl ou un client compatible OpenAI :
curl -s -X POST "http://localhost:8000/v1/completions" \
-H "Content-Type: application/json" \
-d '{"model":"DeepSeek-V3.1","prompt":"Explain the QuickSort algorithm", "max_tokens":200}'
Les recettes et la documentation vLLM incluent des exemples DeepSeek et des notes sur la compatibilité FP8 et le parallélisme multi-GPU/pipeline. Pour les modèles lourds, plusieurs GPU ou une variante quantifiée seront toujours nécessaires.
Option C — LMDeploy / SGLang / LightLLM et TensorRT-LLM (hautes performances)
Le référentiel DeepSeek recommande explicitement SG Lang, Déploiement LMDet TensorRT-LLM En tant que moteurs optimisés pour DeepSeek V3, ils offrent une latence d'inférence, un débit et des noyaux FP8 améliorés.
Une invocation LMDeploy typique (reportez-vous à la documentation LMDeploy pour la CLI exacte) :
# pseudo-example; refer to LMDeploy docs for exact options
lmdeploy serve --model /path/to/deepseek_v3.1 --precision fp8 --port 8080
Les benchmarks et les recettes de lancement de SGLang sont disponibles dans le référentiel et dans le projet SGLang benchmark/deepseek_v3 dossier. Utilisez ces piles lorsque vous contrôlez un cluster GPU et souhaitez un débit de production.
Option D — Ollama (la voie de développement local la plus simple, souvent sur une seule machine)
Si vous souhaitez la méthode la moins contraignante pour exécuter DeepSeek localement (et que vous pouvez épargner le disque), Ollama fournit des modèles packagés et une interface de ligne de commande simple (ollama pull, ollama run). DeepSeek-V3.1 apparaît dans la bibliothèque Ollama et peut être exécuté localement (Ollama peut nécessiter une version récente/pré-version pour certaines fonctionnalités).
Exemple (Ollama CLI) :
# Pull the model (downloads the model artifacts to your disk)
ollama pull deepseek-v3.1
# Start an interactive session:
ollama run deepseek-v3.1
# Or run as a local API server (Ollama supports a local API)
# Example: POSTing to Ollama's local API (adjust host/port to your setup)
curl -X POST http://localhost:11434/api/generate \
-H 'Content-Type: application/json' \
-d '{"model":"deepseek-v3.1","prompt":"Summarize the following paper: ..."}'
Ollama fait abstraction de nombreux détails de distribution/quantification et constitue un excellent moyen de tester le comportement d'un modèle sur un seul hôte. Remarque : la page du modèle indique une taille de paquet d'environ 404 Go pour l'entrée Ollama ; prévoyez donc l'espace disque et la RAM en conséquence.
Qu'est-ce que le mode de réflexion et comment l'utiliser
DeepSeek-V3.1 implémente un jeton de pensée hybride approche : le même point de contrôle peut s'exécuter dans thinking mode (jetons internes de « chaîne de pensée ») ou non-pensée en changeant le modèle de discussion/invite. Le modèle utilise des jetons explicites comme <think> (et fermeture </think> (dans certains modèles) pour signaler une chaîne de pensée interne par rapport à une génération de réponse directe. La carte modèle documente les préfixes de pensée et de non-pensée et montre les différences entre les modèles.
Exemple : construction d'un message en Python (assistant de tokenisation)
La carte du modèle « Hugging Face » inclut un extrait pratique expliquant comment appliquer le modèle de chat via le tokenizer. Voici le modèle recommandé pour la génération. thinking or non-pensée invites formatées :
import transformers
tokenizer = transformers.AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")
messages = [
{"role": "system", "content": "You are a helpful assistant"},
{"role": "user", "content": "Who are you?"},
{"role": "assistant", "content": "<think>Hmm</think>I am DeepSeek"},
{"role": "user", "content": "1+1=?"}
]
# Thinking mode
tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)
# Non-thinking mode
tokenizer.apply_chat_template(messages, tokenize=False, thinking=False, add_generation_prompt=True)
Basculer thinking=True pour produire une invite qui utilise le <think> préfixe; thinking=False Produit le modèle de non-réflexion. Le modèle se comportera différemment (délibération interne ou réponse immédiate) selon cet indicateur.
Référence rapide — petits dépannages et meilleures pratiques
Si vous manquez de mémoire GPU : Essayez les builds quantifiés (AWQ/q4/INT4) ou les GFU communautaires ; de nombreux espaces communautaires publient des quantifications pour une utilisation locale. Ollama/vLLM peut également servir à des builds quantifiés plus petits.
Si vous avez besoin que le modèle appelle des outils externes : Adoptez le Appel d'outil Schéma exact dans le modèle de discussion. Testez le format JSON de l'outil hors ligne et vérifiez que votre code d'orchestration (l'élément qui exécute l'outil) renvoie du JSON purifié et typé au modèle.
Si vous avez besoin d'un contexte plus long : Utilisez vLLM ou SGLang avec des plugins à contexte long ; DeepSeek a été explicitement formé/étendu pour les contextes 32 128/XNUMX XNUMX, et les outils associés prennent en charge cette fenêtre. Attendez-vous à des compromis en termes de mémoire.
Puis-je réellement exécuter DeepSeek-V3.1 sur un ordinateur portable ou un petit serveur ?
Réponse courte: Oui, mais avec des réserves. Les quantifications communautaires (AWQ/GGUF/dynamique 1 bit) réduisent considérablement l'empreinte mémoire et le stockage, et permettent aux amateurs d'exécuter les variantes V3.1 sur des ordinateurs de bureau haut de gamme (prétentions d'environ 170 Go de mémoire de travail). Cependant :
- Compromis entre fidélité et taille : La quantification agressive réduit la mémoire, mais peut affecter les performances du raisonnement et du code. Testez sur vos charges de travail.
- Juridique et licences : le modèle est sous licence MIT selon la fiche modèle, mais les quantifications tierces peuvent porter leurs propres licences ; examinez-les avant utilisation en production.
Mot de la fin
DeepSeek-V3.1 constitue une avancée significative vers des modèles d'agents hybrides avec des comportements explicites de réflexion et de non-réflexion et une meilleure utilisation des outils. Si vous souhaitez l'exécuter localement, choisissez une solution adaptée à votre matériel et à votre tolérance au risque :
Pour la recherche : transformers + safetensors quantifiés et accélérer.
Pour la production et le débit : vLLM + multi-GPU (H100/H200).
Pour les expériences locales : Ollama/llama.cpp + GFU communautaires (fusion + exécution).
Pour commencer
CometAPI est une plateforme d'API unifiée qui regroupe plus de 500 modèles d'IA provenant de fournisseurs leaders, tels que la série GPT d'OpenAI, Gemini de Google, Claude d'Anthropic, Midjourney, Suno, etc., au sein d'une interface unique et conviviale pour les développeurs. En offrant une authentification, un formatage des requêtes et une gestion des réponses cohérents, CometAPI simplifie considérablement l'intégration des fonctionnalités d'IA dans vos applications. Que vous développiez des chatbots, des générateurs d'images, des compositeurs de musique ou des pipelines d'analyse pilotés par les données, CometAPI vous permet d'itérer plus rapidement, de maîtriser les coûts et de rester indépendant des fournisseurs, tout en exploitant les dernières avancées de l'écosystème de l'IA.
Les développeurs peuvent accéder DeepSeek-V3.1 Grâce à CometAPI, les dernières versions des modèles répertoriées correspondent à la date de publication de l'article. Pour commencer, explorez les fonctionnalités du modèle dans la section cour de récréation et consultez le Guide de l'API Pour des instructions détaillées, veuillez vous connecter à CometAPI et obtenir la clé API avant d'y accéder. API Comet proposer un prix bien inférieur au prix officiel pour vous aider à vous intégrer.