Comment exécuter Deepseek V3 0324 en local (avec étapes)

Bienvenue ! Dans ce tutoriel, je vais vous guider à travers l'exécution de DeepSeek V3 0324, un puissant modèle de langage de 671 milliards de paramètres, sur votre machine locale. Nous couvrirons tout, de la préparation à l'exécution de vos premières invites en utilisant des techniques de quantification dynamique qui équilibrent la précision du modèle avec les exigences de mémoire.

DeepSeek V3 0324 : Dans quelle mesure est-il bon ?

La mise à jour de mars 2024 de DeepSeek apporte des améliorations significatives des performances par rapport au modèle V3 précédent :

• Le score MMLU-Pro s'est amélioré de +5,3 % (à 81,2 %)
• Le score AIME s'est amélioré de +19,8 %
• Le score LiveCodeBench s'est amélioré de +10,0 %
• Le score GPQA s'est amélioré de +9,3 %

Le modèle original est un modèle massif de 671 milliards de paramètres, ce qui signifie que nous avons besoin de techniques de quantification efficaces pour l'exécuter sur du matériel grand public.

Voici les options de quantification disponibles pour équilibrer l'espace disque et la précision :

Le modèle float8 d'origine prend 715 Go, ces versions quantifiées offrent donc des économies d'espace importantes !

Tutoriel étape par étape : Exécution de DeepSeek V3 0324 dans llama.cpp

Avant de commencer, comprenons les paramètres optimaux pour DeepSeek V3 0324 :

• Température : 0,3 (utiliser 0,0 pour les tâches de codage)
• Min_P : 0,01 (aide à filtrer les jetons peu probables)
• Modèle de discussion : <｜User｜>YOUR_PROMPT<｜Assistant｜>
• Pour la quantification du cache KV, utilisez 8 bits (pas 4 bits) pour de meilleures performances

Étape 1 : Configurer llama.cpp

Tout d'abord, nous devons obtenir et compiler llama.cpp :

# Mettre à jour les paquets et installer les dépendances requises
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

# Cloner le dépôt llama.cpp
git clone <https://github.com/ggml-org/llama.cpp>

# Construire avec le support CUDA pour le GPU (utiliser -DGGML_CUDA=OFF pour le CPU uniquement)
# Remarque : la construction avec CUDA peut prendre environ 5 minutes
cmake llama.cpp -B llama.cpp/build \\\\
  -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON

# Construire les outils nécessaires
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split

# Copier les outils construits pour un accès facile
cp llama.cpp/build/bin/llama-* llama.cpp/

Étape 2 : Télécharger le modèle quantifié

Installez les paquets Python requis et téléchargez le modèle :

pip install huggingface_hub hf_transfer

# Configurer l'environnement pour des téléchargements plus rapides
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"

# Télécharger le modèle (ici, nous utilisons la quantification dynamique de 2,7 bits pour l'équilibre)
from huggingface_hub import snapshot_download
snapshot_download(
  repo_id = "unsloth/DeepSeek-V3-0324-GGUF",
  local_dir = "unsloth/DeepSeek-V3-0324-GGUF",
  allow_patterns = ["*UD-Q2_K_XL*"],  # Dynamique 2.7bit (230GB)
  # Utiliser "*UD-IQ_S*" pour Dynamique 1.78bit (151GB) si l'espace est limité
)

Étape 3 : Exécuter une invite de test

Testons le modèle avec une invite lui demandant de créer un jeu Flappy Bird :

./llama.cpp/llama-cli \\\\
  --model unsloth/DeepSeek-V3-0324-GGUF/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \\\\
  --cache-type-k q8_0 \\\\
  --threads 20 \\\\
  --n-gpu-layers 2 \\\\
  -no-cnv \\\\
  --prio 3 \\\\
  --temp 0.3 \\\\
  --min_p 0.01 \\\\
  --ctx-size 4096 \\\\
  --seed 3407 \\\\
  --prompt "<｜User｜>Créez un jeu Flappy Bird en Python. Vous devez inclure ces éléments :
1. Vous devez utiliser pygame.
2. La couleur d'arrière-plan doit être choisie au hasard et est une nuance claire. Commencez par une couleur bleu clair.
3. Appuyer plusieurs fois sur ESPACE accélérera l'oiseau.
4. La forme de l'oiseau doit être choisie au hasard comme un carré, un cercle ou un triangle. La couleur doit être choisie au hasard comme une couleur foncée.
5. Placez en bas une terre de couleur marron foncé ou jaune choisie au hasard.
6. Faites un score affiché en haut à droite. Incrémentez si vous passez des tuyaux et ne les touchez pas.
7. Faites des tuyaux espacés au hasard avec suffisamment d'espace. Colorez-les au hasard en vert foncé ou marron clair ou une nuance de gris foncé.
8. Lorsque vous perdez, affichez le meilleur score. Mettez le texte à l'intérieur de l'écran. Appuyer sur q ou Échap quittera le jeu. Redémarrer consiste à appuyer à nouveau sur ESPACE.
Le jeu final doit se trouver à l'intérieur d'une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<｜Assistant｜>"

Voici les explications des paramètres :

• -model : Chemin d'accès au fichier du modèle
• -cache-type-k q8_0 : Utilise une quantification de 8 bits pour le cache KV
• -threads 20 : Nombre de threads CPU (ajuster en fonction de votre CPU)
• -n-gpu-layers 2 : Nombre de couches à décharger sur le GPU (ajuster si vous avez des problèmes de mémoire)
• no-cnv : Désactive la convolution pour des raisons de performances
• -prio 3 : Réglage de la priorité
• -temp 0.3 : Réglage de la température (utiliser 0,0 pour le codage déterministe)
• -min_p 0.01 : Probabilité minimale pour l'échantillonnage des jetons
• -ctx-size 4096 : Taille de la fenêtre contextuelle
• -seed 3407 : Grain aléatoire pour la reproductibilité

Tester Deepseek V3 0324 avec le « Heptagon Challenge »

Vous pouvez tester davantage les capacités de votre modèle en exécutant le « Heptagon Challenge », qui demande au modèle de créer une simulation physique complexe avec des balles rebondissant à l'intérieur d'un heptagone en rotation :

./llama.cpp/llama-cli \\\\
  --model unsloth/DeepSeek-V3-0324-GGUF/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \\\\
  --cache-type-k q8_0 \\\\
  --threads 20 \\\\
  --n-gpu-layers 2 \\\\
  -no-cnv \\\\
  --prio 3 \\\\
  --temp 0.3 \\\\
  --min_p 0.01 \\\\
  --ctx-size 4096 \\\\
  --seed 3407 \\\\
  --prompt "<｜User｜>Écrivez un programme Python qui montre 20 balles rebondissant à l'intérieur d'un heptagone en rotation :
- Toutes les balles ont le même rayon.
- Toutes les balles ont un numéro dessus de 1 à 20.
- Toutes les balles tombent du centre de l'heptagone au démarrage.
- Les couleurs sont : #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35
- Les balles doivent être affectées par la gravité et le frottement, et elles doivent rebondir sur les murs en rotation de manière réaliste. Il devrait également y avoir des collisions entre les balles.
- Le matériau de toutes les balles détermine que leur hauteur de rebond d'impact ne dépassera pas le rayon de l'heptagone, mais sera supérieure au rayon de la balle.
- Toutes les balles tournent avec frottement, les numéros sur la balle peuvent être utilisés pour indiquer la rotation de la balle.
- L'heptagone tourne autour de son centre, et la vitesse de rotation est de 360 degrés toutes les 5 secondes.
- La taille de l'heptagone doit être suffisamment grande pour contenir toutes les balles.
- N'utilisez pas la bibliothèque pygame ; implémentez vous-même les algorithmes de détection de collision et la réponse aux collisions, etc. Les bibliothèques Python suivantes sont autorisées : tkinter, math, numpy, dataclasses, typing, sys.
- Tous les codes doivent être placés dans un seul fichier Python.<｜Assistant｜>"

Optimisation des performances de Deepseek V3 0324

Flash Attention : Pour un décodage plus rapide, utilisez Flash Attention lors de la compilation de llama.cpp :

-DGGML_CUDA_FA_ALL_QUANTS=ON

Architecture CUDA : Définissez votre architecture CUDA spécifique pour réduire les temps de compilation :

-DCMAKE_CUDA_ARCHITECTURES="80"  # Ajuster pour votre GPU

Ajustement des paramètres :

• Si vous rencontrez des problèmes de mémoire insuffisante, essayez de réduire -n-gpu-layers
• Pour l'inférence sur le processeur uniquement, supprimez le paramètre -n-gpu-layers
• Ajustez -threads en fonction de vos cœurs de processeur

Vous avez maintenant DeepSeek V3 0324 qui s'exécute localement ! Pour récapituler :

1. Nous avons configuré llama.cpp avec la prise en charge de CUDA
2. Téléchargé une version quantifiée du modèle (quantification dynamique de 2,7 bits)
3. Exécuté des invites de test pour vérifier les capacités du modèle
4. Appris les paramètres optimaux et les conseils de performance

La quantification dynamique de 2,7 bits offre un excellent équilibre entre l'espace disque (231 Go) et la précision du modèle, ce qui vous permet d'exécuter ce modèle de 671 milliards de paramètres efficacement sur votre propre matériel.

N'hésitez pas à expérimenter différentes invites et paramètres pour tirer le meilleur parti de ce puissant modèle !

Tester l'API DeepSeek avec Apidog

Si vous développez des applications qui utilisent DeepSeek via son API plutôt que de l'exécuter localement, Apidog fournit des outils puissants pour le développement, les tests et le débogage d'API.

Configuration d'Apidog pour les tests d'API DeepSeek

Étape 1 : Télécharger et installer Apidog

1. Visitez https://apidog.com/download/ pour télécharger le client Apidog pour votre système d'exploitation.

2. Installez et lancez Apidog, puis créez un compte ou connectez-vous avec Google/Github.

3. Lorsque vous y êtes invité, sélectionnez votre rôle (par exemple, « Développeur fullstack ») et votre mode de travail préféré (par exemple, « Conception d'API d'abord »).

Étape 2 : Créer un nouveau projet d'API pour DeepSeek

1. Créez un nouveau projet HTTP dans Apidog pour vos tests d'API DeepSeek.
2. Ajoutez vos points de terminaison d'API DeepSeek au projet.

Débogage des réponses en streaming de DeepSeek

DeepSeek et de nombreux autres modèles d'IA utilisent les événements envoyés par le serveur (SSE) pour les réponses en streaming. Apidog (version 2.6.49 ou supérieure) prend en charge le débogage SSE :

1. Créez et configurez votre point de terminaison d'API DeepSeek dans Apidog.
2. Envoyez la requête à votre API DeepSeek.
3. Si la réponse inclut l'en-tête Content-Type: text/event-stream, Apidog la traite automatiquement comme un événement SSE.
4. Affichez les réponses en streaming en temps réel dans la vue Chronologie du panneau de réponse.

Apidog prend en charge les formats de modèles d'IA populaires, notamment :

• Format compatible avec l'API OpenAI
• Format compatible avec l'API Gemini
• Format compatible avec l'API Claude

Pour DeepSeek en particulier, Apidog peut afficher le processus de réflexion du modèle dans la chronologie, fournissant ainsi un aperçu du raisonnement de l'IA.

Personnalisation de la gestion des réponses SSE pour DeepSeek

Si le format de réponse de DeepSeek ne correspond pas aux règles de reconnaissance intégrées d'Apidog, vous pouvez :

Configurer les règles d'extraction JSONPath pour les réponses SSE au format JSON :

• Pour une réponse comme : data: {"choices":[{"index":0,"message":{"role":"assistant","content":"H"}}]}
• Utiliser JSONPath : $.choices[0].message.content

Utiliser des scripts de post-traitement pour les messages SSE non JSON :

• Écrire des scripts personnalisés pour gérer le format de données
• Traiter les messages en fonction de vos exigences spécifiques

Création de tests automatisés pour les API DeepSeek

Une fois que vous avez configuré votre point de terminaison d'API DeepSeek, vous pouvez créer des tests automatisés dans Apidog pour vous assurer qu'il fonctionne correctement :

1. Créez des scénarios de test pour différents types d'invites dans le module Tests.
2. Ajoutez la validation et les assertions pour vérifier la structure et le contenu de la réponse.
3. Configurez le scénario de test pour qu'il s'exécute avec différents environnements (par exemple, développement, production).
4. Configurez des exécutions par lots pour tester plusieurs scénarios à la fois.

Pour l'intégration CI/CD, Apidog CLI vous permet d'exécuter ces tests dans le cadre de votre pipeline :

# Installer Apidog CLI
npm install -g apidog-cli

# Exécuter le scénario de test
apidog run test-scenario -c <collection-id> -e <environment-id> -k <api-key>

Vous pouvez en savoir plus sur le fonctionnement d'apidog-cli dans la Documentation officielle.

Tests de performance de l'API DeepSeek

Apidog offre également des capacités de test de performance pour évaluer les performances de votre API DeepSeek sous charge :

Créez un scénario de test qui inclut des appels à votre API DeepSeek.

Configurez les paramètres du test de performance :

• Définissez le nombre d'utilisateurs virtuels (jusqu'à 100)
• Spécifiez la durée du test
• Configurez la durée de montée en puissance pour simuler une augmentation progressive des utilisateurs

Exécutez le test de performance pour voir les mesures clés telles que :

• Débit moyen
• Temps de réponse moyen
• Temps de réponse maximum/minimum
• Taux d'erreur

Ceci est particulièrement utile pour comprendre comment votre déploiement DeepSeek gère plusieurs requêtes simultanées.

Conclusion

Vous avez maintenant DeepSeek V3 0324 qui s'exécute localement et les connaissances nécessaires pour tester efficacement les API DeepSeek à l'aide d'Apidog ! Pour récapituler :

• Nous avons configuré llama.cpp avec la prise en charge de CUDA
• Téléchargé une version quantifiée du modèle (quantification dynamique de 2,7 bits)
• Exécuté des invites de test pour vérifier les capacités du modèle
• Appris à utiliser Apidog pour tester et déboguer les API DeepSeek
• Exploré les conseils d'optimisation des performances pour le déploiement local et les tests d'API

La quantification dynamique de 2,7 bits offre un excellent équilibre entre l'espace disque (231 Go) et la précision du modèle, ce qui vous permet d'exécuter ce modèle de 671 milliards de paramètres efficacement sur votre propre matériel. Pendant ce temps, Apidog vous offre des outils puissants pour développer, tester et déboguer les implémentations d'API DeepSeek, en particulier avec ses capacités de débogage SSE pour les réponses en streaming.

N'hésitez pas à expérimenter différentes options de quantification et fonctionnalités d'Apidog pour trouver la configuration qui convient le mieux à vos besoins spécifiques !