Past het op een DGX Spark? LLM-geheugencalculator
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
| Model | Gewichten | Over van 121,6 GiB | Oordeel |
|---|---|---|---|
| Llama 3.3 70B, AWQ 4-bit | ongeveer 37 GiB (log van GPUwerk) | ongeveer 84 GiB, ongeveer 82 GiB na 8.192 tokens KV voor één gebruiker | Past. Het geheugen laat ruimte voor een team; de snelheid niet (GPUwerk mat 6,0 tok/s voor één gebruiker) |
| gpt-oss-120b, MXFP4 | 65,2 GB (60,8 GiB), Hugging Face-repo | ongeveer 61 GiB vóór KV en overhead | Past. 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.
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:
- Gewichten (GB) = totaal aantal parameters in miljarden x bytes per parameter. Een 70B-model is ongeveer 140 GB in FP16, 70 GB in FP8 en 37 GB in 4-bit, dezelfde getallen als op de modellenpagina.
- KV-cache (bytes) = 2 x lagen x KV-heads x headdimensie x bytes per waarde x tokens x sequenties. De 2 staat voor één key en één value per head.
- Decodeplafond (tok/s) = 273 GB/s gedeeld door de GB aan gewichten van actieve parameters die per token worden gelezen. Dit is een rekenkundig plafond, geen verwachte snelheid. Volgens de benchmarkpagina van GPUwerk halen echte engines ruwweg 50 tot 80% daarvan, en daar staat ook waar de eigen runs van GPUwerk uitkwamen.
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.
| Model | KV per token | Gelogde KV-tokens bij 0,85 | KV-grootte volgens de formule | Controleberekening |
|---|---|---|---|---|
| Llama 3.3 70B AWQ | 327.680 bytes (80 lagen, 8 KV-heads, 128 dim, FP16) | 207.120 | 63,2 GiB | 37 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 AWQ | 98.304 bytes (48 lagen, 4 KV-heads, 128 dim, FP16) | 924.912 | 84,7 GiB | Laat 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.
| Model | Gebruikte grootte | Bron (aggregator) | Waarom het niet past |
|---|---|---|---|
| DeepSeek V4.1-Flash, Q2_K | 324 GB (763,2B parameters) | llmrun.dev | Ongeveer 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-bit | ongeveer 1.570 GB (2,8T parameters x 0,56) | slash-digital.io | 12 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.