DGX Spark/Geheugencalculator
Calculator

Past het op een DGX Spark? LLM-geheugencalculator

Door Samuel Seidel · Gepubliceerd op 11 oktober 2026 · 6 min. lezen

Een 70B-model in 4-bit heeft ongeveer 37 GiB aan gewichten nodig, waardoor er van de 121,6 GiB adresseerbare unified memory van een DGX Spark ongeveer 84 GiB overblijft voor KV-cache en overhead; in FP16 (ongeveer 140 GB) past hetzelfde model niet. gpt-oss-120b past ook: de MXFP4-gewichten zijn samen 65,2 GB (60,8 GiB), en er blijft ongeveer 61 GiB over. Vul hieronder je eigen model in; de formules en hun beperkingen staan onder de calculator. Ik run GPUwerk, dat DGX Sparks verhuurt, dus houd dat in je achterhoofd bij hoe ik het breng.

Twee uitgewerkte antwoorden

ModelGewichtenOver van 121,6 GiBOordeel
Llama 3.3 70B, AWQ 4-bitongeveer 37 GiB (log van GPUwerk)ongeveer 84 GiB, ongeveer 82 GiB na 8.192 tokens KV voor één gebruikerPast. Het geheugen laat ruimte voor een team; de snelheid niet (GPUwerk mat 6,0 tok/s voor één gebruiker)
gpt-oss-120b, MXFP465,2 GB (60,8 GiB), Hugging Face-repoongeveer 61 GiB vóór KV en overheadPast. Tussen de lijnen van 40 en 75 GB, dus een paar gebruikers passen als de KV-cache klein blijft

De 37 GiB aan Llama-gewichten, de 6,0 tok/s en het getal van 121,6 GiB komen uit de vLLM-documentatie, de pagina over Llama 3.3 70B en de benchmarkpagina van GPUwerk. De grootte van gpt-oss-120b is de som van de MXFP4-safetensors-bestanden in openai/gpt-oss-120b op Hugging Face, gecontroleerd op 2026-10-11; llama.cpp meldt de MXFP4-GGUF als 59,02 GiB in discussie #16578. GPUwerk heeft het geheugengebruik van gpt-oss-120b niet gemeten. Het aftrekken en de KV-grootte zijn mijn eigen rekenwerk.

Passen is maar de helft: een dense 70B die makkelijk past, genereert nog steeds ongeveer 6 tokens per seconde voor één request, omdat elk token alle gewichten leest. Welke grote modellen snel genoeg draaien op één Spark vergelijkt dense en mixture-of-experts-modellen met gemeten en gemelde snelheden.

Calculator

Alles draait in je browser en er wordt niets opgeslagen of verstuurd. Kies een preset of typ je eigen getallen. De resultaten verschijnen onder het formulier en worden bijgewerkt terwijl je typt.

Model

Vul je eigen cijfers in.

KV-cache
Machine
Vul hierboven een model in om de schatting te zien. Zonder JavaScript gebruik je de formules hieronder of de twee uitgewerkte antwoorden hierboven.

De standaardoverhead van 4 GiB is mijn aanname, gebaseerd op "een paar gigabyte" voor activaties en de CUDA-context op de modellenpagina. De optie van 64 GB halveert de door GPUwerk waargenomen 121,6 GiB; GPUwerk heeft die variant niet gedraaid. De modus met twee nodes gaat ervan uit dat gewichten en KV gelijk worden verdeeld.

Zo werkt de schatting

Drie formules, allemaal gewoon rekenwerk:

Bytes per parameter zijn gemiddelden, geen exacte waarden. FP16 is 2 en FP8 is 1. De 4-bit-formaten (INT4, AWQ, NVFP4, MXFP4) komen uit tussen 0,5 en 0,56 als je de schalen meetelt, en deze pagina gebruikt standaard 0,56. Een 2-bit GGUF is ongeveer 0,3. Dynamische GGUF-quants mengen bitbreedtes, dus gepubliceerde bestandsgroottes zijn betrouwbaarder dan welke formule ook.

Het oordeel volgt de vuistregel van de modellenpagina. Minder dan ongeveer 40 GB aan gewichten per node laat ruimte om een team te bedienen, meer dan ongeveer 75 GB is een model voor één gebruiker, en een negatieve marge betekent dat het niet past. De band van 40 tot 75 GB daartussen is mijn lezing van die regel: het past, maar de KV-cache bepaalt hoeveel gebruikers passen. KV-cachegroottes voor 22 actuele modellen, berekend uit elke config.json, staan in KV-cachegrootte per model.

De formule toetsen aan de logs van GPUwerk

De vLLM-runs van GPUwerk legden vast hoeveel KV-tokens passen bij een GPU-geheugenbenutting van 0,85. De logs zijn de maatstaf; de formule hoeft er alleen dicht bij te komen.

ModelKV per tokenGelogde KV-tokens bij 0,85KV-grootte volgens de formuleControleberekening
Llama 3.3 70B AWQ327.680 bytes (80 lagen, 8 KV-heads, 128 dim, FP16)207.12063,2 GiB37 GiB gewichten + 63,2 GiB KV = 100,2 GiB, tegenover een budget van 0,85 x 121,6 = 103,4 GiB. De resterende 3,2 GiB is overhead van de engine.
Qwen3-Coder 30B-A3B AWQ98.304 bytes (48 lagen, 4 KV-heads, 128 dim, FP16)924.91284,7 GiBLaat 18,7 GiB van het budget van 103,4 GiB over voor gewichten en overhead. Parameters x 0,56 geeft ongeveer 16 GiB aan gewichten, wat overeenkomt.

KV-tokens en het getal van 37 GiB: de pagina's en logs van GPUwerk over Llama 3.3 70B en Qwen3-Coder 30B-A3B. Aantallen lagen, heads en dimensies: de config.json-bestanden van de modellen op Hugging Face (mirror van Llama 3.3 70B, Qwen3-Coder, gpt-oss-120b), gecontroleerd op 2026-10-11. De controleberekeningen zijn mijn eigen rekenwerk.

Eén eenheidskwestie: de benchmarkpagina en de pagina over Llama 3.3 70B van GPUwerk delen 273 GB/s door 37 en komen zo op een plafond van 7,4 tok/s, waarbij de gelogde 37 GiB als 37 GB worden behandeld. Omgerekend (37 GiB is 39,7 GB) is het plafond 6,9 tok/s, en de calculator gebruikt dat getal. Tegenover 6,9 is de gemeten 6,0 tok/s ongeveer 87% van het plafond, iets boven de band van 50 tot 80%.

Waarom unified memory anders is

Een losse GPU heeft zijn eigen VRAM, en het model past daarin of loopt over via een trage PCIe-verbinding. De DGX Spark heeft één pool van 128 GB LPDDR5x die CPU en GPU delen. Volgens de logs van GPUwerk is daarvan ongeveer 121,6 GiB adresseerbaar, en daarin moeten het besturingssysteem, Docker, de paginacache en alle andere processen passen, naast je gewichten en KV-cache.

De releasenotes van de DGX Spark van NVIDIA (gecontroleerd op 2026-10-11) vermelden dat het voor het beeldscherm gereserveerde geheugen in de release van juli 2026 instelbaar is: standaard 2 GB, 4 GB via het BIOS. Gebruik je een beeldscherm, controleer dan wat je eigen systeem meldt met free -h voordat je een model tot op de laatste gigabyte dimensioneert. GPUwerk draait zijn Sparks bovendien zonder swap sinds een geheugenhardening op 9 september 2026, dus opraken betekent een out-of-memory-fout, geen vertraging.

De pool is ook de reden dat bandbreedte en niet capaciteit de snelheid begrenst: 273 GB/s voedt elk token, dus een dense 70B-model leest ongeveer 37 GiB per token, terwijl een mixture-of-experts-model met 3B actief minder dan 2 GB leest. Zie de specspagina voor de volledige hardwarelijst.

Voor een losse GPU of een Mac doet FitLocally dezelfde soort controle of een model past, voor ongeveer 110 open modellen op grafische kaarten, Macs en mini-pc's. Het is een aparte site die ik publiceer.

Modellen die niet op één Spark passen

De calculator bevat twee voorbeelden die niet passen. Beide zijn gebaseerd op pagina's van aggregators, niet op modelkaarten of cijfers van GPUwerk zelf, dus behandel de groottes als indicatief.

ModelGebruikte grootteBron (aggregator)Waarom het niet past
DeepSeek V4.1-Flash, Q2_K324 GB (763,2B parameters)llmrun.devOngeveer 2,5 keer de 121,6 GiB (130,6 GB) van één Spark, en meer dan twee Sparks samen bevatten (ongeveer 261 GB)
Kimi K3, 4-bitongeveer 1.570 GB (2,8T parameters x 0,56)slash-digital.io12 keer de capaciteit van één Spark

Gecontroleerd op 2026-10-11. De 4-bit-grootte van Kimi is mijn eigen vermenigvuldiging, geen gepubliceerde quant.

Twee Sparks, en de variant met 64 GB

Twee gekoppelde Sparks geven je twee pools van 121,6 GiB, geen 256 GB voor één model. De calculator verdeelt gewichten en KV gelijk en controleert elke node, wat optimistisch is, omdat echte verdelingen zelden perfect gelijk zijn. Voor de opzet, zie de handleiding voor een cluster van twee nodes. Om een model op echte hardware te proberen voordat je koopt, legt de pagina over huren uit hoe je per minuut huurt.

De productpagina van NVIDIA noemt een variant met 64 GB die via OEM-partners wordt verkocht (zie de specspagina), en het bericht van The Register van 2 oktober 2026 behandelt de aankondiging, inclusief de ongewijzigde bandbreedte van 273 GB/s (gecontroleerd op 2026-10-11). GPUwerk heeft er geen gedraaid, dus het getal van 60,8 GiB in de calculator is de helft van 121,6 en niets meer. Bij die grootte zou het voorbeeld met 70B in 4-bit (37 GiB) ongeveer 24 GiB overlaten vóór overhead en KV. De handleiding over 64 GB vs 128 GB rekent door welke actuele modellen op elk passen.

FAQ

Hoeveel geheugen heeft een 70B-model nodig?

Gewichten zijn parameters maal bytes per parameter: ongeveer 140 GB in FP16, 70 GB in FP8 en 37 GB in 4-bit, zoals de modellenpagina uiteenzet. Op een DGX Spark met ongeveer 121,6 GiB adresseerbaar past FP16 niet, past FP8 (70 GB) maar net onder de grens van 75 GB waar het een model voor één gebruiker wordt, en laat 4-bit ongeveer 84 GiB over vóór de KV-cache. Llama 3.3 70B voegt in FP16 327.680 bytes KV-cache per token toe, dus 8.192 tokens voor één sequentie is ongeveer 2,7 GB.

Past gpt-oss-120b op een DGX Spark?

Ja. De MXFP4-gewichten in de Hugging Face-repository van OpenAI zijn samen 65,2 GB (60,8 GiB), waardoor er van de 121,6 GiB adresseerbaar geheugen ongeveer 61 GiB overblijft voor KV-cache en overhead. GPUwerk heeft het geheugengebruik en de snelheid van dit model niet gemeten. De ongeveer 60 tok/s die er vaak voor wordt genoemd onder llama.cpp is een melding van derden (tg32 bij een lege context, dalend tot ongeveer 40 tok/s bij 32.768 tokens context), geen meting van GPUwerk.

Wat is unified memory voor LLM's?

De DGX Spark heeft één pool van 128 GB LPDDR5x die CPU en GPU allebei gebruiken, dus er is geen apart VRAM. Gewichten, KV-cache, het besturingssysteem, Docker en de paginacache putten allemaal uit dezelfde pool, en een model dat "te groot is voor het VRAM" is gewoon te groot voor wat er van die pool over is. Het betekent ook dat 273 GB/s bandbreedte, niet capaciteit, de decodesnelheid bepaalt.

Betekenen twee Sparks 256 GB voor één model?

Nee. Twee gekoppelde Sparks zijn twee aparte pools van 121,6 GiB die via een netwerkverbinding zijn gekoppeld, geen pool van 256 GB. Een model moet over beide worden verdeeld, bijvoorbeeld met tensor- of pipelineparallellisme, en elke node heeft nog steeds zijn deel van de gewichten, KV-cache en overhead nodig. Deze pagina controleert per node of het past en doet geen uitspraak over snelheid met twee nodes; het enige gemeten paar van GPUwerk, Qwen3-32B met tensorparallellisme, staat op de benchmarkpagina. De handleiding voor een cluster van twee nodes behandelt de opzet.

Hoe nauwkeurig is deze calculator?

Het is een schatting, geen exact getal. Het laat enginebuffers, CUDA-graphs, kwantisatiemetadata bovenop het gemiddelde aantal bytes per parameter, en engine-specifieke allocatie zoals de vooraf gedimensioneerde KV-pool van vLLM buiten beschouwing. Voor Llama 3.3 70B AWQ liggen de schatting en de benchmarklogs van GPUwerk binnen ongeveer 3 GiB van elkaar, en de logs zijn de maatstaf. Test een echte belasting voordat je je op een configuratie vastlegt.

Eerste opwaardering: betaal $ 20, krijg $ 30 tegoed

Controleer de schatting op een echte Spark.

Huur een dedicated DGX Spark in Europa, Noord-Amerika of Oost-Azië voor $ 0,79/uur, per minuut gefactureerd, en laad het model dat je net hebt doorgerekend.

Account aanmaken Bekijk prijzen