Esegui modelli di classe da 70B a 120B in 128 GB di memoria unificata
Una DGX Spark ha 128 GB di memoria condivisa tra CPU e GPU, quindi i modelli che non entrerebbero mai in una scheda grafica da 24 o 32 GB si caricano in un unico blocco. Entrarci non vuol dire andare veloce. La memoria ha una banda di 273 GB/s e ogni token generato legge una volta i pesi attivi del modello. Su una delle mie Spark un Llama 3.3 70B denso ha generato 6,0 token al secondo per una singola richiesta. Un modello mixture-of-experts legge solo una parte dei suoi pesi per token: gpt-oss-120b è riportato a 58,7 tok/s sullo stesso chip. Scegli il modello in base alla banda, poi noleggia una Spark per le ore che ti servono.
Prima ricarica: paghi 20 $, ricevi 30 $ di credito, circa 37 ore su una Spark. Fatturazione al minuto dal credito prepagato. Termina quando hai finito e la fatturazione si ferma.
Cosa ci sta, e quanto è veloce una singola richiesta
| Modello e formato | Letti per token | Una richiesta | Fonte |
|---|---|---|---|
| Qwen3-Coder 30B-A3B, AWQ a 4 bit | circa 3B parametri | 80,9 tok/s | La mia prova, vLLM 0.27.1, 2 set 2026 (log grezzo) |
| gpt-oss-120b, MXFP4 | 5.1B su 117B | 58,7 tok/s | Riportato: risultati DGX Spark di llama.cpp, build 7941, 5 feb 2026 |
| gpt-oss-120b, MXFP4 | 5.1B su 117B | 33,5 tok/s | Riportato: Dendro Logic, vLLM, prompt da 1.500 token e output JSON, 22 apr 2026 |
| Nemotron-3-Super-120B-A12B, NVFP4 | 12B su 120B | circa 24 tok/s | Riportato: forum NVIDIA, vLLM con una correzione CUTLASS, 29 mar 2026 |
| Llama 3.3 70B, AWQ a 4 bit | tutti i 70B (denso) | 6,0 tok/s | La mia prova, vLLM 0.27.1, 2 set 2026 (log grezzo) |
| Nemotron Super 49B v1.5, NVFP4 | tutti i 49B (denso) | 5,79 tok/s | Riportato: Dendro Logic, 22 apr 2026 |
| Qwen3-235B-A22B, UD-Q4_K_XL (134 GB) | 22B su 235B | circa 1,8 tok/s; non ci sta | Riportato: forum NVIDIA, llama.cpp, 17 dic 2025 |
Le righe "Riportato" sono misurazioni di altri, che ho raccolto e verificato con le loro fonti l'11 ottobre 2026 per la pagina dei benchmark; non le ho riprodotte. Le due righe di gpt-oss-120b mostrano quanto motore e carico di lavoro spostano un modello sullo stesso chip. Il numero di parametri di gpt-oss-120b viene dalla sua model card, tramite il calcolatore di memoria.
Perché un 70B denso è lento e un MoE da 120B no
Generare un token significa leggere una volta i pesi attivi dalla memoria, quindi il limite è la banda di memoria divisa per i byte letti per 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)
I motori reali si collocano tra circa la metà e i quattro quinti del limite. Sotto i 10 tok/s circa un modello sembra lento in una finestra di chat, ed è per questo che un 70B denso su una Spark è un modello da batch: con 128 richieste in corso la mia prova con il 70B ha raggiunto 485 tok/s in totale, contando token del prompt e generati, ma ogni richiesta è scesa a 1,4 tok/s. Le curve di concorrenza complete sono nella pagina dei benchmark.
Cosa eseguirei
- Un modello di classe 120B con cui conversare: gpt-oss-120b in MXFP4. I pesi occupano 65,2 GB, il che lascia spazio per un contesto lungo, e legge circa 5B parametri per token.
- Prima la velocità: un modello mixture-of-experts Qwen3 a 4 bit, come Qwen3-30B-A3B o Qwen3.6-35B-A3B. Questi leggono circa 3B parametri per token.
- Un 70B denso: solo per job batch, o quando ti serve proprio quel modello. Aspettati circa 6 tok/s per richiesta.
- Quantizza a 4 bit. MXFP4, NVFP4, AWQ o Q4_K_M dimezzano i byte per token rispetto a FP8 e circa raddoppiano il limite. Il costo in qualità varia per formato; la guida alla velocità di quantizzazione li confronta su questo chip.
- Oltre 128 GB: due Spark collegate, a 1 $,79 all'ora per il cluster a due nodi quando la console lo offre. Il resoconto su Qwen3-235B qui sopra è passato da circa 1,8 tok/s su una Spark a circa 12,5 su due. La guida ai due nodi spiega cosa offre l'abbinamento.
Esegui gpt-oss-120b con llama.cpp
Per un utente alla volta, llama.cpp è il motore più veloce su questo chip. Avvia DGX Spark 1× con l'immagine DGX OS, apri il terminale nel browser, compila llama.cpp per il GB10 (da 5 a 10 minuti) e avvia il modello. I passaggi di build sono gli stessi della mia guida a 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
Quando il log dice che il server è in ascolto, misura la tua velocità da un secondo terminale. llama-server restituisce le sue tempistiche con ogni risposta:
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")'
Il download viene conteggiato nel tempo, quindi avvialo per primo e leggi mentre si carica. Per raggiungere il server dal tuo laptop, usa un tunnel SSH con la tua chiave, oppure avvialo con --host 0.0.0.0 --api-key e una chiave casuale lunga: ogni istanza ha il proprio indirizzo IPv4 pubblico. Per più utenti contemporanei, vLLM gestisce meglio i batch; la guida a vLLM riporta i calcoli di memoria per la memoria unificata.
Limiti da conoscere prima
- Non ho misurato gpt-oss-120b sulla mia flotta. I suoi numeri qui sopra sono riportati, e i tuoi prompt daranno risultati diversi. Misura prima di basare i tuoi piani su un dato.
- I prompt lunghi sono lenti sui grandi modelli densi. La mia prova con il 70B ha letto un prompt di 8.192 token a 391 tok/s, circa 21 secondi prima del primo token.
- La quantizzazione costa qualità. Un modello a 4 bit non è quello a precisione piena. Verifica le risposte sui tuoi prompt.
- La Spark è ARM64 con una GPU sm_121. Motori e pacchetti Python richiedono build aarch64, e un semplice
pip install vllmpuò installarsi senza errori e poi non avviarsi; la guida a vLLM spiega la trappola. - Gira in un container. Su molte Spark ha un proprio daemon Docker, quindi i container arm64 dei produttori funzionano; le altre eseguono un container semplice senza Docker, dove la strada è la build nativa qui sopra. Non puoi scegliere quale.
- Nessuno SLA e nessun backup. I download di modelli fuori da
/workspacevanno persi con una ricostruzione, e la terminazione elimina tutto.
Prezzo e dove si trovano le Spark
0 $,79 all'ora per una Spark, fatturati al minuto dal credito prepagato: 6 $,32 per una giornata di otto ore. Prima ricarica: paghi 20 $, ricevi 30 $ di credito. Un'istanza arrestata mantiene il suo workspace ed è fatturata al 75% della tariffa oraria. Termina quando hai finito e la fatturazione si ferma; il workspace viene eliminato. Prezzi IVA esclusa, ove applicabile.
Le mie Spark sono in un data center a Hradec Králové, in Repubblica Ceca. Le Spark partner, di proprietà di partner e ospitate presso le loro sedi, si trovano negli USA, in Svezia, nei Paesi Bassi, in Slovacchia e a Hong Kong; un partner ha accesso fisico alla sua macchina. La console mostra il paese, e se è nel SEE, prima del deploy. Ogni ubicazione offre le immagini DGX OS e Ubuntu usate sopra.
Chi gestisce tutto questo
GPUwerk è nuova. La gestisco io, Samuel Seidel, tramite PRINT IT! SE, società registrata a Praga. Al 9 novembre 2026, 94 sviluppatori hanno avviato 374 istanze da settembre. Lo stato in tempo reale è su status.gpuwerk.com, e la pagina dei contatti arriva direttamente a me se vuoi verificare un modello prima di noleggiare.
FAQ
Una DGX Spark può eseguire un modello 70B?
Sì. Llama 3.3 70B in AWQ a 4 bit occupa circa 37 GiB di pesi e ci sta con margine, ma ha generato 6,0 token al secondo per una singola richiesta su una delle mie Spark (vLLM 0.27.1, 2 settembre 2026). È più adatto ai job batch che alla chat.
gpt-oss-120b ci sta su una sola DGX Spark?
Sì. I suoi pesi MXFP4 totalizzano 65,2 GB, e legge circa 5,1B parametri per token. I maintainer di llama.cpp riportano 58,7 tok/s per una richiesta; Dendro Logic riporta 33,5 su vLLM con prompt più lunghi e output JSON. Non l'ho misurato sulla mia flotta.
E i modelli più grandi di 128 GB?
Richiedono due Spark collegate. Una build di Qwen3-235B-A22B da 134 GB è girata a circa 1,8 tok/s su una Spark e a circa 12,5 su due, secondo un resoconto sul forum per sviluppatori NVIDIA. Il cluster a due nodi di GPUwerk costa 1 $,79 all'ora quando la console lo offre.
Quanto costa provare un modello grande?
0 $,79 all'ora per una Spark, fatturati al minuto dal credito prepagato; il primo download e la compilazione di llama.cpp girano su quel conteggio. Prima ricarica: paghi 20 $, ricevi 30 $ di credito, circa 37 ore. Termina quando hai finito e la fatturazione si ferma.