DGX Spark/Minnekalkulator
Kalkulator

Får det plass på en DGX Spark? LLM-minnekalkulator

Av Samuel Seidel · Publisert 11. oktober 2026 · 6 min lesetid

En 70B-modell i 4-bit trenger omtrent 37 GiB med vekter, noe som etterlater omtrent 84 GiB av de 121,6 GiB adresserbart enhetlig minne i en DGX Spark til KV-cache og overhead; i FP16 (omtrent 140 GB) får den samme modellen ikke plass. gpt-oss-120b får også plass: MXFP4-vektene er på 65,2 GB (60,8 GiB) totalt, så det blir omtrent 61 GiB igjen. Skriv inn din egen modell nedenfor; formlene og begrensningene står etter kalkulatoren. Jeg driver GPUwerk, som leier ut DGX Spark-maskiner, så vurder fremstillingen med det i tankene.

To gjennomregnede svar

ModellVekterIgjen av 121,6 GiBKonklusjon
Llama 3.3 70B, AWQ 4-bitomtrent 37 GiB (GPUwerk-logg)omtrent 84 GiB, omtrent 82 GiB etter 8 192 tokens KV for én brukerFår plass. Minnet gir rom for et team; hastigheten gjør det ikke (GPUwerk målte 6,0 tok/s for én bruker)
gpt-oss-120b, MXFP465,2 GB (60,8 GiB), Hugging Face-repoomtrent 61 GiB før KV og overheadFår plass. Mellom linjene for 40 og 75 GB, så noen få brukere får plass hvis KV-cachen holdes liten

Llama-vektene på 37 GiB, de 6,0 tok/s og tallet på 121,6 GiB kommer fra GPUwerks vLLM-dokumentasjon, side om Llama 3.3 70B og benchmarkside. Størrelsen på gpt-oss-120b er summen av MXFP4-safetensors-filene i openai/gpt-oss-120b på Hugging Face, kontrollert 2026-10-11; llama.cpp rapporterer MXFP4-GGUF-en til 59,02 GiB i diskusjon #16578. GPUwerk har ikke målt minneforbruket til gpt-oss-120b. Subtraksjonen og KV-størrelsen er min egen utregning.

Å få plass er bare halve saken: en tett 70B-modell som lett får plass, genererer fortsatt omtrent 6 tokens per sekund for én forespørsel, fordi hvert token leser alle vektene. Hvilke store modeller som kjører raskt nok på én Spark sammenligner tette modeller og mixture-of-experts-modeller med målte og rapporterte hastigheter.

Kalkulator

Alt kjører i nettleseren din, og ingenting lagres eller sendes. Velg en forhåndsinnstilling eller skriv inn dine egne tall. Resultatene vises under skjemaet og oppdateres mens du skriver.

Modell

Skriv inn dine egne tall.

KV-cache
Maskin
Skriv inn en modell ovenfor for å se anslaget. Uten JavaScript kan du bruke formlene nedenfor eller de to gjennomregnede svarene ovenfor.

Standardverdien på 4 GiB overhead er min antakelse, basert på modellsidens "noen få gigabyte" for aktiveringer og CUDA-konteksten. Alternativet med 64 GB halverer GPUwerks observerte 121,6 GiB; GPUwerk har ikke kjørt den varianten. Modusen med to noder forutsetter at vekter og KV fordeles jevnt.

Slik fungerer anslaget

Tre formler, alle enkel regning:

Byte per parameter er gjennomsnitt, ikke eksakte tall. FP16 er 2 og FP8 er 1. 4-bitsformatene (INT4, AWQ, NVFP4, MXFP4) havner mellom 0,5 og 0,56 når skalaene regnes med, og denne siden bruker 0,56 som standard. En 2-bits GGUF er omtrent 0,3. Dynamiske GGUF-kvantiseringer blander bitbredder, så publiserte filstørrelser slår enhver formel.

Vurderingen følger tommelfingerregelen fra modellsiden. Under omtrent 40 GB vekter per node gir rom til å betjene et team, over omtrent 75 GB er en modell for én bruker, og negativ margin betyr at den ikke får plass. Intervallet 40 til 75 GB mellom dem er min tolkning av regelen: den får plass, men KV-cachen avgjør hvor mange brukere som får plass. KV-cache-størrelser for 22 aktuelle modeller, regnet ut fra hver config.json, står i KV-cache-størrelse per modell.

Kontroll av formelen mot GPUwerks logger

GPUwerks vLLM-kjøringer logget hvor mange KV-tokens som fikk plass ved 0,85 GPU-minneutnyttelse. Loggene er fasiten; formelen trenger bare å havne i nærheten av dem.

ModellKV per tokenLoggede KV-tokens ved 0,85KV-størrelse etter formelKrysssjekk
Llama 3.3 70B AWQ327 680 byte (80 lag, 8 KV-hoder, 128 dim, FP16)207 12063,2 GiB37 GiB vekter + 63,2 GiB KV = 100,2 GiB, mot et budsjett på 0,85 x 121,6 = 103,4 GiB. De resterende 3,2 GiB er motorens overhead.
Qwen3-Coder 30B-A3B AWQ98 304 byte (48 lag, 4 KV-hoder, 128 dim, FP16)924 91284,7 GiBEtterlater 18,7 GiB av budsjettet på 103,4 GiB til vekter og overhead. Parametere x 0,56 gir omtrent 16 GiB vekter, noe som stemmer.

KV-tokens og tallet på 37 GiB: GPUwerks sider og logger for Llama 3.3 70B og Qwen3-Coder 30B-A3B. Antall lag, hoder og dimensjoner: modellenes config.json-filer på Hugging Face (speil av Llama 3.3 70B, Qwen3-Coder, gpt-oss-120b), kontrollert 2026-10-11. Summene i krysssjekken er min egen utregning.

Én enhetsdetalj: GPUwerks benchmarkside og siden om Llama 3.3 70B deler 273 GB/s på 37 og får et tak på 7,4 tok/s, og behandler de loggede 37 GiB som 37 GB. Omregnet (37 GiB er 39,7 GB) er taket 6,9 tok/s, og kalkulatoren bruker det tallet. Mot 6,9 er de målte 6,0 tok/s omtrent 87 % av taket, litt over intervallet 50 til 80 %.

Hvorfor enhetlig minne er annerledes

En separat GPU har sitt eget VRAM, og modellen får enten plass der eller renner over til en treg PCIe-forbindelse. DGX Spark har én minnepool på 128 GB LPDDR5x som deles av CPU og GPU. GPUwerks logger viser omtrent 121,6 GiB av det som adresserbart, og det må dekke operativsystemet, Docker, sidecachen og alle andre prosesser i tillegg til vektene og KV-cachen din.

NVIDIAs utgivelsesnotater for DGX Spark (kontrollert 2026-10-11) oppgir at minnet som er reservert til skjerm, kan justeres i utgivelsen fra juli 2026: 2 GB som standard, 4 GB via BIOS. Hvis du kjører en skjerm, sjekk hva ditt eget system rapporterer med free -h før du dimensjonerer en modell til siste gigabyte. GPUwerk kjører også Spark-maskinene sine uten swap siden en runde med minneherding 9. september 2026, så går minnet tomt, gir det en out-of-memory-feil, ikke en nedbremsing.

Minnepoolen er også grunnen til at båndbredde, ikke kapasitet, begrenser hastigheten: 273 GB/s mater hvert token, så en tett 70B-modell leser omtrent 37 GiB per token, mens en mixture-of-experts-modell med 3B aktive leser under 2 GB. Se spesifikasjonssiden for hele maskinvarelisten.

For et separat grafikkort eller en Mac kjører FitLocally samme type passformsjekk for rundt 110 åpne modeller på tvers av grafikkort, Mac-er og mini-PC-er. Det er et eget nettsted jeg publiserer.

Modeller som ikke får plass på én Spark

Kalkulatoren inneholder to eksempler som ikke får plass. Begge bygger på aggregatorsider, ikke modellkort eller GPUwerks egne tall, så behandle størrelsene som veiledende.

ModellBrukt størrelseKilde (aggregator)Hvorfor det mislykkes
DeepSeek V4.1-Flash, Q2_K324 GB (763,2B parametere)llmrun.devOmtrent 2,5 ganger de 121,6 GiB i én Spark (130,6 GB), og mer enn to Spark-maskiner rommer til sammen (omtrent 261 GB)
Kimi K3, 4-bitomtrent 1 570 GB (2,8T parametere x 0,56)slash-digital.io12 ganger kapasiteten til én Spark

Kontrollert 2026-10-11. Størrelsen på 4-bits Kimi er min egen multiplikasjon, ikke en publisert kvantisering.

To Spark-maskiner, og varianten med 64 GB

To koblede Spark-maskiner gir deg to minnepooler på 121,6 GiB, ikke 256 GB for én modell. Kalkulatoren fordeler vekter og KV jevnt og sjekker hver node, noe som er optimistisk fordi ekte fordelinger sjelden er helt jevne. For oppsett, se guiden om klynger med to noder. For å prøve en modell på ekte maskinvare før du kjøper, forklarer siden om hvordan du leier leie per minutt.

NVIDIAs produktside oppgir en variant med 64 GB som selges gjennom OEM-partnere (se spesifikasjonssiden), og The Registers sak fra 2. oktober 2026 dekker kunngjøringen, inkludert den uendrede båndbredden på 273 GB/s (kontrollert 2026-10-11). GPUwerk har ikke kjørt en, så kalkulatorens tall på 60,8 GiB er halvparten av 121,6 og ikke noe mer. Med den størrelsen ville 4-bits 70B-eksempelet (37 GiB) etterlate omtrent 24 GiB før overhead og KV. Guiden 64 GB mot 128 GB går gjennom hvilke aktuelle modeller som får plass på hver.

Spørsmål og svar

Hvor mye minne trenger en 70B-modell?

Vektene er parametere ganger byte per parameter: omtrent 140 GB i FP16, 70 GB i FP8 og 37 GB i 4-bit, slik modellsiden viser. På en DGX Spark med omtrent 121,6 GiB adresserbart får FP16 ikke plass, FP8 (70 GB) får plass, men ligger like under 75 GB-linjen der den blir en modell for én bruker, og 4-bit etterlater omtrent 84 GiB før KV-cache. Llama 3.3 70B legger til 327 680 byte KV-cache per token i FP16, så 8 192 tokens for én sekvens er omtrent 2,7 GB.

Får gpt-oss-120b plass på en DGX Spark?

Ja. MXFP4-vektene i OpenAIs Hugging Face-repositorium er på 65,2 GB (60,8 GiB) totalt, noe som etterlater omtrent 61 GiB av de 121,6 GiB adresserbare minnet til KV-cache og overhead. GPUwerk har ikke målt denne modellens minneforbruk eller hastighet. De omtrent 60 tok/s som ofte siteres for den med llama.cpp, er en tredjepartsrapport (tg32 på tom kontekst, som faller til omtrent 40 tok/s ved 32 768 tokens kontekst), ikke en måling fra GPUwerk.

Hva er enhetlig minne for LLM-er?

DGX Spark har én minnepool på 128 GB LPDDR5x som både CPU-en og GPU-en bruker, så det finnes ikke eget VRAM. Vekter, KV-cache, operativsystemet, Docker og sidecachen henter alle fra den samme minnepoolen, og en modell som er 'for stor for VRAM', er rett og slett for stor for det som er igjen av minnepoolen. Det betyr også at det er båndbredden på 273 GB/s, ikke kapasiteten, som bestemmer dekodingshastigheten.

Betyr to Spark-maskiner 256 GB for én modell?

Nei. To koblede Spark-maskiner er to separate minnepooler på 121,6 GiB forbundet med en nettverksforbindelse, ikke én minnepool på 256 GB. En modell må deles mellom dem, for eksempel med tensor- eller pipelineparallellisme, og hver node trenger fortsatt sin andel av vektene, KV-cachen og overheaden. Denne siden sjekker om det får plass per node og hevder ingenting om hastighet med to noder; GPUwerk’s eneste målte par, Qwen3-32B med tensorparallellisme, står på benchmarksiden. Guiden om klynger med to noder dekker oppsettet.

Hvor nøyaktig er denne kalkulatoren?

Det er et anslag, ikke et eksakt tall. Det utelater motorbuffere, CUDA-grafer, kvantiseringsmetadata utover gjennomsnittet for byte per parameter, og motorspesifikk allokering som vLLMs forhåndsdimensjonerte KV-pool. For Llama 3.3 70B AWQ stemmer anslaget og GPUwerks benchmarklogger overens innenfor omtrent 3 GiB, og loggene er fasiten. Test en reell belastning før du binder deg til en konfigurasjon.

Første påfylling: betal 20 $, få 30 $ i kreditt

Sjekk anslaget på en ekte Spark.

Lei en dedikert DGX Spark i Europa, Nord-Amerika eller Øst-Asia for 0 $,79/h, fakturert per minutt, og last inn modellen du nettopp har beregnet.

Opprett konto Se priser