Faites tourner des modèles de classe 70B à 120B dans 128 Go de mémoire unifiée
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 format | Lus par token | Une requête | Source |
|---|---|---|---|
| Qwen3-Coder 30B-A3B, AWQ 4 bits | environ 3B paramètres | 80,9 tok/s | Mon test, vLLM 0.27.1, 2 sept. 2026 (log brut) |
| gpt-oss-120b, MXFP4 | 5,1B sur 117B | 58,7 tok/s | Rapporté : résultats llama.cpp sur DGX Spark, build 7941, 5 févr. 2026 |
| gpt-oss-120b, MXFP4 | 5,1B sur 117B | 33,5 tok/s | Rapporté : Dendro Logic, vLLM, prompts de 1 500 tokens et sortie JSON, 22 avr. 2026 |
| Nemotron-3-Super-120B-A12B, NVFP4 | 12B sur 120B | environ 24 tok/s | Rapporté : forum NVIDIA, vLLM avec un correctif CUTLASS, 29 mars 2026 |
| Llama 3.3 70B, AWQ 4 bits | tous les 70B (dense) | 6,0 tok/s | Mon test, vLLM 0.27.1, 2 sept. 2026 (log brut) |
| Nemotron Super 49B v1.5, NVFP4 | tous les 49B (dense) | 5,79 tok/s | Rapporté : Dendro Logic, 22 avr. 2026 |
| Qwen3-235B-A22B, UD-Q4_K_XL (134 Go) | 22B sur 235B | environ 1,8 tok/s ; ne tient pas | Rapporté : 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
- Un modèle de classe 120B avec lequel vous pouvez discuter : gpt-oss-120b en MXFP4. Les poids font 65,2 Go, ce qui laisse de la place pour un long contexte, et il lit environ 5B paramètres par token.
- La vitesse avant tout : un modèle mixture-of-experts Qwen3 en 4 bits, comme Qwen3-30B-A3B ou Qwen3.6-35B-A3B. Ceux-ci lisent environ 3B paramètres par token.
- Un 70B dense : uniquement pour des traitements par lots, ou si vous avez besoin de ce modèle précis. Comptez environ 6 tok/s par requête.
- Quantifiez en 4 bits. MXFP4, NVFP4, AWQ ou Q4_K_M divisent par deux les octets par token par rapport au FP8 et doublent à peu près le plafond. Le coût en qualité diffère selon le format ; le guide sur la vitesse de quantification les compare sur cette puce.
- Au-delà de 128 Go : deux Sparks reliés, à 1,79 $ de l'heure pour le cluster de deux nœuds quand la console le propose. Le test Qwen3-235B rapporté ci-dessus est passé d'environ 1,8 tok/s sur un Spark à environ 12,5 sur deux. Le guide à deux nœuds explique ce que l'appairage apporte.
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
- Je n'ai pas mesuré gpt-oss-120b sur ma flotte. Ses chiffres ci-dessus sont rapportés, et vos prompts donneront un autre résultat. Mesurez avant de vous organiser autour d'un chiffre.
- Les longs prompts sont lents sur les grands modèles denses. Mon test 70B a lu un prompt de 8 192 tokens à 391 tok/s, soit environ 21 secondes avant le premier token.
- La quantification coûte en qualité. Un modèle 4 bits n'est pas le modèle en pleine précision. Vérifiez les réponses sur vos propres prompts.
- Le Spark est en ARM64 avec un GPU sm_121. Les moteurs et les paquets Python ont besoin de versions aarch64, et un simple
pip install vllmpeut s'installer sans erreur puis ne pas démarrer ; le guide vLLM explique ce piège. - Il tourne dans un conteneur. Sur beaucoup de Sparks, il a son propre démon Docker, si bien que les conteneurs arm64 des éditeurs fonctionnent ; les autres font tourner un conteneur simple sans Docker, où la compilation native ci-dessus est la voie à suivre. Vous ne pouvez pas choisir.
- Ni SLA ni sauvegardes. Les modèles téléchargés hors de
/workspacesont perdus lors d'une reconstruction, et supprimer l'instance efface tout.
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.