Får det plats på en DGX Spark? LLM-minneskalkylator
En 70B-modell i 4 bitar behöver cirka 37 GiB vikter, vilket lämnar cirka 84 GiB av en DGX Sparks 121,6 GiB adresserbara enhetliga minne för KV-cache och overhead; i FP16 (cirka 140 GB) får samma modell inte plats. gpt-oss-120b får också plats: dess MXFP4-vikter är totalt 65,2 GB (60,8 GiB), vilket lämnar cirka 61 GiB. Ange din egen modell nedan; formlerna och deras begränsningar följer efter kalkylatorn. Jag driver GPUwerk, som hyr ut DGX Sparks, så väg in det när du läser.
Två uträknade svar
| Modell | Vikter | Kvar av 121,6 GiB | Bedömning |
|---|---|---|---|
| Llama 3.3 70B, AWQ 4-bitars | cirka 37 GiB (GPUwerks logg) | cirka 84 GiB, cirka 82 GiB efter 8 192 tokens KV för en användare | Får plats. Minnet räcker för ett team; hastigheten gör det inte (GPUwerk mätte 6,0 tok/s för en användare) |
| gpt-oss-120b, MXFP4 | 65,2 GB (60,8 GiB), Hugging Face-repo | cirka 61 GiB före KV och overhead | Får plats. Mellan linjerna för 40 och 75 GB, så några användare får plats om KV-cachen hålls liten |
Llama-vikterna på 37 GiB, 6,0 tok/s och siffran 121,6 GiB kommer från GPUwerks vLLM-dokumentation, sida om Llama 3.3 70B och benchmarksida. Storleken för gpt-oss-120b är summan av MXFP4-safetensors-filerna i openai/gpt-oss-120b på Hugging Face, kontrollerad 2026-10-11; llama.cpp rapporterar MXFP4-GGUF:en som 59,02 GiB i diskussion #16578. GPUwerk har inte mätt minnesavtrycket för gpt-oss-120b. Subtraktionen och KV-storleken är min egen beräkning.
Att få plats är bara halva saken: en tät 70B som lätt får plats genererar ändå bara cirka 6 tokens per sekund för en förfrågan, eftersom varje token läser alla dess vikter. Vilka stora modeller som körs tillräckligt snabbt på en Spark jämför täta modeller och mixture-of-experts-modeller med uppmätta och rapporterade hastigheter.
Kalkylator
Allt körs i din webbläsare och ingenting sparas eller skickas. Välj en förinställning eller skriv in dina egna siffror. Resultaten visas under formuläret och uppdateras medan du skriver.
Standardvärdet på 4 GiB overhead är mitt antagande, baserat på modellsidans ”några gigabyte” för aktiveringar och CUDA-kontexten. Alternativet 64 GB skalar GPUwerks observerade 121,6 GiB till hälften; GPUwerk har inte kört den varianten. Läget med två noder förutsätter att vikter och KV delas jämnt.
Så fungerar uppskattningen
Tre formler, all enkel aritmetik:
- Vikter (GB) = totalt antal parametrar i miljarder x byte per parameter. En 70B-modell är cirka 140 GB i FP16, 70 GB i FP8 och 37 GB i 4 bitar, samma siffror som på modellsidan.
- KV-cache (byte) = 2 x lager x KV-huvuden x huvuddimension x byte per värde x tokens x sekvenser. Tvåan är en nyckel och ett värde per huvud.
- Avkodningstak (tok/s) = 273 GB/s delat med antalet GB vikter för aktiva parametrar som läses per token. Det här är ett aritmetiskt tak, inte en förväntad hastighet. GPUwerks benchmarksida placerar riktiga motorer på ungefär 50 till 80 % av det och visar var GPUwerks egna körningar hamnade.
Byte per parameter är genomsnitt, inte exakta värden. FP16 är 2 och FP8 är 1. 4-bitarsformaten (INT4, AWQ, NVFP4, MXFP4) hamnar mellan 0,5 och 0,56 när skalfaktorerna räknas med, och den här sidan använder 0,56 som standard. En 2-bitars GGUF är cirka 0,3. Dynamiska GGUF-kvantiseringar blandar bitbredder, så publicerade filstorlekar slår alla formler.
Bedömningen följer modellsidans tumregel. Under cirka 40 GB vikter per nod lämnar utrymme för att betjäna ett team, över cirka 75 GB är en modell för en användare, och negativ marginal betyder att den inte får plats. Intervallet 40 till 75 GB däremellan är min tolkning av den regeln: den får plats, men KV-cachen avgör hur många användare som får plats. KV-cachestorlekar för 22 aktuella modeller, uträknade från varje config.json, finns i KV-cachestorlek per modell.
Kontroll av formeln mot GPUwerks loggar
GPUwerks vLLM-körningar loggade hur många KV-tokens som fick plats vid 0,85 i GPU-minnesutnyttjande. Loggarna är facit; formeln behöver bara hamna nära dem.
| Modell | KV per token | Loggade KV-tokens vid 0,85 | KV-storlek enligt formel | Korskontroll |
|---|---|---|---|---|
| Llama 3.3 70B AWQ | 327 680 byte (80 lager, 8 KV-huvuden, 128 dim, FP16) | 207 120 | 63,2 GiB | 37 GiB vikter + 63,2 GiB KV = 100,2 GiB, mot en budget på 0,85 x 121,6 = 103,4 GiB. De återstående 3,2 GiB är motorns overhead. |
| Qwen3-Coder 30B-A3B AWQ | 98 304 byte (48 lager, 4 KV-huvuden, 128 dim, FP16) | 924 912 | 84,7 GiB | Lämnar 18,7 GiB av budgeten på 103,4 GiB för vikter och overhead. Parametrar x 0,56 ger cirka 16 GiB vikter, vilket stämmer. |
KV-tokens och siffran 37 GiB: GPUwerks sidor och loggar för Llama 3.3 70B och Qwen3-Coder 30B-A3B. Antal lager, huvuden och dimensioner: modellernas config.json-filer på Hugging Face (spegel för Llama 3.3 70B, Qwen3-Coder, gpt-oss-120b), kontrollerade 2026-10-11. Summorna i korskontrollen är min egen beräkning.
En enhetsdetalj: GPUwerks benchmarksida och sidan om Llama 3.3 70B delar 273 GB/s med 37 och får ett tak på 7,4 tok/s, där de loggade 37 GiB behandlas som 37 GB. Omräknat (37 GiB är 39,7 GB) blir taket 6,9 tok/s, och kalkylatorn använder den siffran. Mot 6,9 är de uppmätta 6,0 tok/s cirka 87 % av taket, lite över intervallet 50 till 80 %.
Varför enhetligt minne är annorlunda
En separat GPU har sitt eget VRAM, och modellen får antingen plats där eller svämmar över via en långsam PCIe-länk. DGX Spark har en pool på 128 GB LPDDR5x som delas av CPU och GPU. GPUwerks loggar visar att cirka 121,6 GiB av den är adresserbar, och det ska räcka till operativsystemet, Docker, sidcachen och alla andra processer utöver dina vikter och din KV-cache.
NVIDIA:s versionsinformation för DGX Spark (kontrollerad 2026-10-11) anger att minnet som reserveras för skärm går att justera i versionen från juli 2026: 2 GB som standard, 4 GB via BIOS. Om du kör en skärm, kontrollera vad ditt eget system rapporterar med free -h innan du dimensionerar en modell till sista gigabyten. GPUwerk kör också sina Sparks utan swap sedan en genomgång för minneshärdning den 9 september 2026, så att minnet tar slut ger ett out-of-memory-fel, inte en nedsaktning.
Poolen är också anledningen till att bandbredd snarare än kapacitet begränsar hastigheten: 273 GB/s matar varje token, så en tät 70B-modell läser cirka 37 GiB per token medan en mixture-of-experts-modell med 3B aktiva läser under 2 GB. Se specifikationssidan för hela hårdvarulistan.
För ett separat grafikkort eller en Mac gör FitLocally samma slags passningskontroll för cirka 110 öppna modeller på grafikkort, Mac-datorer och minidatorer. Det är en separat webbplats som jag publicerar.
Modeller som inte får plats på en Spark
Kalkylatorn innehåller två exempel som inte får plats. Båda bygger på aggregatorsidor, inte modellkort eller GPUwerks egna siffror, så se storlekarna som ungefärliga.
| Modell | Använd storlek | Källa (aggregator) | Varför det misslyckas |
|---|---|---|---|
| DeepSeek V4.1-Flash, Q2_K | 324 GB (763,2B parametrar) | llmrun.dev | Cirka 2,5 gånger en Sparks 121,6 GiB (130,6 GB), och mer än två Sparks rymmer tillsammans (cirka 261 GB) |
| Kimi K3, 4-bitars | cirka 1 570 GB (2,8T parametrar x 0,56) | slash-digital.io | 12 gånger kapaciteten hos en Spark |
Kontrollerat 2026-10-11. Storleken för Kimi i 4 bitar är min multiplikation, inte en publicerad kvantisering.
Två Sparks, och varianten med 64 GB
Två länkade Sparks ger dig två pooler på 121,6 GiB, inte 256 GB för en enda modell. Kalkylatorn delar vikter och KV jämnt och kontrollerar varje nod, vilket är optimistiskt eftersom verkliga uppdelningar sällan är helt jämna. För installation, se guiden för kluster med två noder. För att prova en modell på riktig hårdvara innan du köper förklarar sidan om att hyra hur du hyr per minut.
NVIDIA:s produktsida listar en variant med 64 GB som säljs via OEM-partner (se specifikationssidan), och The Registers rapport från 2 oktober 2026 täcker tillkännagivandet, inklusive den oförändrade bandbredden på 273 GB/s (kontrollerad 2026-10-11). GPUwerk har inte kört någon, så kalkylatorns siffra på 60,8 GiB är hälften av 121,6 och inget mer. Vid den storleken skulle exemplet med 70B i 4 bitar (37 GiB) lämna cirka 24 GiB före overhead och KV. Guiden 64 GB mot 128 GB går igenom vilka aktuella modeller som får plats på respektive.
Vanliga frågor
Hur mycket minne behöver en 70B-modell?
Vikterna är parametrar gånger byte per parameter: cirka 140 GB i FP16, 70 GB i FP8 och 37 GB i 4 bitar, som modellsidan visar. På en DGX Spark med cirka 121,6 GiB adresserbart får FP16 inte plats, FP8 (70 GB) får plats men ligger strax under 75 GB-gränsen där den blir en modell för en användare, och 4 bitar lämnar cirka 84 GiB före KV-cache. Llama 3.3 70B lägger till 327 680 byte KV-cache per token i FP16, så 8 192 tokens för en sekvens är cirka 2,7 GB.
Får gpt-oss-120b plats på en DGX Spark?
Ja. MXFP4-vikterna i OpenAI:s Hugging Face-repository är totalt 65,2 GB (60,8 GiB), vilket lämnar cirka 61 GiB av de 121,6 GiB adresserbart minne för KV-cache och overhead. GPUwerk har inte mätt den här modellens minnesavtryck eller hastighet. De cirka 60 tok/s som ofta anges för den med llama.cpp är en tredjepartsrapport (tg32 med tom kontext, som sjunker till cirka 40 tok/s vid 32 768 tokens kontext), inte en mätning från GPUwerk.
Vad är enhetligt minne för LLM:er?
DGX Spark har en pool på 128 GB LPDDR5x som både CPU och GPU använder, så det finns inget separat VRAM. Vikter, KV-cache, operativsystemet, Docker och sidcachen tar alla från samma pool, och en modell som är ”för stor för VRAM” är helt enkelt för stor för det som finns kvar i den poolen. Det betyder också att det är 273 GB/s bandbredd, inte kapacitet, som avgör avkodningshastigheten.
Betyder två Sparks 256 GB för en modell?
Nej. Två länkade Sparks är två separata pooler på 121,6 GiB sammankopplade med en nätverkslänk, inte en pool på 256 GB. En modell måste delas upp mellan dem, till exempel med tensor- eller pipelineparallellism, och varje nod behöver fortfarande sin andel av vikterna, KV-cachen och overhead. Den här sidan kontrollerar utrymmet per nod och gör inga påståenden om hastighet för två noder; GPUwerks enda uppmätta par, Qwen3-32B med tensorparallellism, finns på benchmarksidan. Guiden för kluster med två noder täcker installationen.
Hur exakt är den här kalkylatorn?
Det är en uppskattning, inte en exakt siffra. Den utelämnar motorbuffertar, CUDA-grafer, kvantiseringsmetadata utöver genomsnittet för byte per parameter, och motorspecifik allokering som vLLM:s förallokerade KV-pool. För Llama 3.3 70B AWQ stämmer uppskattningen och GPUwerks benchmarkloggar överens inom cirka 3 GiB, och loggarna är facit. Testa en verklig belastning innan du bestämmer dig för en konfiguration.