DGX Spark/Grands modèles
Cas d'usage · Grands modèles

Faites tourner des modèles de classe 70B à 120B dans 128 Go de mémoire unifiée

Par Samuel Seidel · Mis à jour le 10 novembre 2026 · Lecture : 7 min

Un DGX Spark dispose de 128 Go de mémoire partagée par son CPU et son GPU : des modèles qui ne tiendraient jamais sur une carte graphique de 24 ou 32 Go se chargent d'un seul bloc. Tenir ne veut pas dire être rapide. La mémoire débite 273 Go/s, et chaque token généré lit une fois les poids actifs du modèle. Sur l'un de mes Sparks, un Llama 3.3 70B dense a généré 6,0 tokens par seconde pour une seule requête. Un modèle mixture-of-experts ne lit qu'une partie de ses poids par token : gpt-oss-120b est mesuré à 58,7 tok/s sur la même puce. Choisissez le modèle en fonction de la bande passante, puis louez un Spark pour les heures dont vous avez besoin.

Première recharge : payez 20 $ recevez 30 $ de crédit, soit environ 37 heures sur un Spark. Facturé à la minute sur crédit prépayé. Supprimez l'instance quand vous avez fini : la facturation s'arrête.

Ce qui tient, et à quelle vitesse tourne une requête

Modèle et formatLus par tokenUne requêteSource
Qwen3-Coder 30B-A3B, AWQ 4 bitsenviron 3B paramètres80,9 tok/sMon test, vLLM 0.27.1, 2 sept. 2026 (log brut)
gpt-oss-120b, MXFP45,1B sur 117B58,7 tok/sRapporté : résultats llama.cpp sur DGX Spark, build 7941, 5 févr. 2026
gpt-oss-120b, MXFP45,1B sur 117B33,5 tok/sRapporté : Dendro Logic, vLLM, prompts de 1 500 tokens et sortie JSON, 22 avr. 2026
Nemotron-3-Super-120B-A12B, NVFP412B sur 120Benviron 24 tok/sRapporté : forum NVIDIA, vLLM avec un correctif CUTLASS, 29 mars 2026
Llama 3.3 70B, AWQ 4 bitstous les 70B (dense)6,0 tok/sMon test, vLLM 0.27.1, 2 sept. 2026 (log brut)
Nemotron Super 49B v1.5, NVFP4tous les 49B (dense)5,79 tok/sRapporté : Dendro Logic, 22 avr. 2026
Qwen3-235B-A22B, UD-Q4_K_XL (134 Go)22B sur 235Benviron 1,8 tok/s ; ne tient pasRapporté : forum NVIDIA, llama.cpp, 17 déc. 2025

Les lignes « rapporté » sont des mesures d'autres personnes, que j'ai rassemblées et vérifiées par rapport à leurs sources le 11 octobre 2026 pour la page des benchmarks ; je ne les ai pas reproduites. Les deux lignes gpt-oss-120b montrent à quel point le moteur et la charge de travail font varier un même modèle sur une même puce. Le nombre de paramètres de gpt-oss-120b provient de sa fiche de modèle, via le calculateur de mémoire.

Pourquoi un 70B dense est lent et un MoE de 120B ne l'est pas

Générer un token signifie lire une fois les poids actifs en mémoire : le plafond est donc la bande passante mémoire divisée par les octets lus par token :

tokens/s ceiling ≈ 273 GB/s ÷ GB of active weights read per token

Llama 3.3 70B, 4-bit:  about 37 GB per token  → about 7.4 tok/s   (measured 6.0)
gpt-oss-120b, MXFP4:   about 3 GB per token   → about 90 tok/s    (reported 58.7)

Les moteurs réels se situent entre environ la moitié et les quatre cinquièmes du plafond. En dessous d'environ 10 tok/s, un modèle semble lent dans une fenêtre de chat, c'est pourquoi un 70B dense sur un seul Spark est un modèle pour le traitement par lots : avec 128 requêtes en cours, mon test 70B a atteint 485 tok/s au total, tokens de prompt et générés confondus, mais chaque requête est tombée à 1,4 tok/s. Les courbes de concurrence complètes sont sur la page des benchmarks.

Ce que je ferais tourner

Faire tourner gpt-oss-120b avec llama.cpp

Pour un seul utilisateur à la fois, llama.cpp est le moteur le plus rapide sur cette puce. Déployez DGX Spark 1× avec l'image DGX OS, ouvrez le terminal du navigateur, compilez llama.cpp pour le GB10 (5 à 10 minutes) et lancez le modèle. Les étapes de compilation sont les mêmes que dans mon guide llama.cpp.

apt-get update && apt-get install -y build-essential cmake libcurl4-openssl-dev
git clone https://github.com/ggml-org/llama.cpp /workspace/llama.cpp
cd /workspace/llama.cpp
cmake -B build -DGGML_CUDA=ON -DGGML_CURL=ON -DCMAKE_CUDA_ARCHITECTURES=121a-real
cmake --build build --config Release --target llama-server -j

# downloads about 65 GB the first time
./build/bin/llama-server -hf ggml-org/gpt-oss-120b-GGUF --jinja \
  --host 127.0.0.1 --port 30000

Quand le log indique que le serveur écoute, mesurez votre propre vitesse depuis un second terminal. llama-server renvoie ses mesures de temps avec chaque réponse :

curl -s http://127.0.0.1:30000/v1/chat/completions -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Explain memory bandwidth in three sentences."}],"max_tokens":300}' \
  | python3 -c 'import json,sys; t=json.load(sys.stdin)["timings"]; print(round(t["predicted_per_second"],1), "tok/s")'

Le téléchargement est facturé : lancez-le donc en premier et lisez pendant qu'il se charge. Pour atteindre le serveur depuis votre ordinateur portable, utilisez un tunnel SSH avec votre propre clé, ou lancez-le avec --host 0.0.0.0 --api-key et une longue clé aléatoire : chaque instance a sa propre adresse IPv4 publique. Pour plusieurs utilisateurs à la fois, vLLM gère mieux les lots ; le guide vLLM détaille le calcul de mémoire pour la mémoire unifiée.

Les limites à connaître d'abord

Prix et emplacement des Sparks

0,79 $ de l'heure pour un Spark, facturé à la minute sur crédit prépayé : 6,32 $ pour une journée de huit heures. Première recharge : payez 20 $ recevez 30 $ de crédit. Une instance arrêtée conserve son espace de travail et est facturée à 75 % du tarif horaire. Supprimez-la quand vous avez fini : la facturation s'arrête et l'espace de travail est effacé. Prix hors TVA le cas échéant.

Mes propres Sparks sont dans un datacenter à Hradec Králové, en République tchèque. Les Sparks partenaires, détenus et hébergés par des partenaires dans leurs propres locaux, se trouvent aux États-Unis, en Suède, aux Pays-Bas, en Slovaquie et à Hong Kong ; un partenaire a un accès physique à sa machine. La console indique le pays, et s'il se trouve dans l'EEE, avant que vous ne déployiez. Chaque emplacement propose les images DGX OS et Ubuntu utilisées ci-dessus.

Qui est derrière

GPUwerk est nouveau. C'est moi qui le dirige, Samuel Seidel, via PRINT IT! SE, une société immatriculée à Prague. Au 9 novembre 2026, 94 développeurs ont lancé 374 instances depuis septembre. L'état du service en temps réel est sur status.gpuwerk.com, et la page de contact me joint directement si vous voulez vérifier un modèle avant de louer.

FAQ

Un DGX Spark peut-il faire tourner un modèle 70B ?

Oui. Llama 3.3 70B en AWQ 4 bits représente environ 37 Gio de poids et tient largement, mais il a généré 6,0 tokens par seconde pour une requête unique sur l'un de mes Sparks (vLLM 0.27.1, 2 septembre 2026). Cela convient mieux aux traitements par lots qu'au chat.

gpt-oss-120b tient-il sur un seul DGX Spark ?

Oui. Ses poids MXFP4 totalisent 65,2 Go, et il lit environ 5,1 milliards de paramètres par token. Les mainteneurs de llama.cpp annoncent 58,7 tok/s pour une requête ; Dendro Logic annonce 33,5 sur vLLM avec des prompts plus longs et une sortie JSON. Je ne l'ai pas mesuré sur ma flotte.

Et les modèles de plus de 128 Go ?

Ils nécessitent deux Sparks reliés. Une version de Qwen3-235B-A22B de 134 Go a tourné à environ 1,8 tok/s sur un Spark et environ 12,5 sur deux, selon un rapport publié sur le forum développeurs de NVIDIA. Le cluster de deux nœuds de GPUwerk coûte 1,79 $ de l'heure quand la console le propose.

Combien coûte l'essai d'un grand modèle ?

0,79 $ de l'heure pour un Spark, facturé à la minute sur crédit prépayé ; le premier téléchargement et la compilation de llama.cpp tournent sur ce compteur. Première recharge : payez 20 $ recevez 30 $ de crédit, soit environ 37 heures. Supprimez l'instance quand vous avez fini : la facturation s'arrête.

Première recharge : payez 20 $ recevez 30 $ de crédit

Chargez un modèle 120B sur un Spark rien qu'à vous.

Un DGX Spark dédié avec 128 Go de mémoire unifiée, 0,79 $/h facturé à la minute. Supprimez l'instance quand vous avez fini : la facturation s'arrête.

Déployer maintenant