sv

LLM-VRAM-räknare

Kontrollera om en lokal språkmodell får plats i VRAM och RAM: vikter, KV-cache, buffert och avlastning var för sig, i GB och GiB, lokalt utan uppladdning.

Den här kalkylatorn ger en icke bindande, modellbaserad uppskattning och är inte finansiell, skatte- eller juridisk rådgivning. Mer i ansvarsfriskrivningen
  • Bangladesh
  • Brasilien
  • Bulgarien
  • Egypten
  • Euroområdet
  • Frankrike
  • Indien
  • Indonesien
  • Italien
  • Japan
  • Kenya
  • Kina
  • Malaysia
  • Mexiko
  • Nederländerna
  • Nigeria
  • Pakistan
  • Polen
  • Portugal
  • Ryssland
  • Spanien
  • Storbritannien
  • Sverige
  • Sydkorea
  • Taiwan
  • Thailand
  • Turkiet
  • Tyskland
  • Ukraina
  • USA
  • Vietnam
Minnestyp
  • Grafikkort med eget VRAM
  • Delat minne (unified memory)
  • Endast CPU, utan GPU
Antal GPU:er
VRAM per grafikkort (GiB)
Uppdelning på flera GPU:er
  • Ingen: modellen måste få plats på en GPU
  • Runtimen fördelar lagren på GPU:erna
Reserv per GPU för skärm och drivrutin (GiB)
Arbetsminne (GiB)
RAM-reserv för system och program (GiB)
Operativsystem (fritext)
Runtime och version (fritext)
Modell och revision (fritext)
Parametrar totalt (miljarder, vid MoE alla experter)
Aktiva parametrar per token (miljarder, endast MoE)
Bitar per vikt (kvantisering, effektivt)
Lager med KV-cache
KV-huvuden (med GQA färre än frågehuvuden)
Dimension per huvud
Använd kontext (token)
KV-cachens precision
  • 16 bit (FP16/BF16)
  • 8 bit
  • 4 bit
Parallella förfrågningar
Körbuffert (GiB, antagande)
Osäkerhet (±)
De oförändrade exempelvärdena gäller för min modell och min dator

Resultat

Endast en exempelberäkning: ändra eller bekräfta värdena
Får modellen plats?
5,65 GB · 5,26 GiB
Totalt minnesbehov
5,08 GB - 6,21 GB (± 10 %)
Osäkerhetsintervall
3,50 GB · 3,26 GiB
Vikter
1,07 GB · 1,00 GiB
KV-cache
1,07 GB · 1,00 GiB
Körbuffert (antagande)
8,05 GB · 7,50 GiB
Användbart GPU-minne
En GPU
Uppdelning på GPU:er
12,88 GB · 12,00 GiB
Ledigt arbetsminne
0,00 GB
Avlastning till arbetsminnet
Endast en exempelberäkning: ändra eller bekräfta värdena
Största kontext som får plats helt (token)
Endast en exempelberäkning: ändra eller bekräfta värdena
Högsta antal bitar som får plats helt
Ej angivet (tät modell)
Aktiva parametrar per token (MoE)
7 × 10⁹ × 4 bit ÷ 8
Beräkning av vikter
2 × 32 × 8 × 128 × 8 192 × 1 × 16 bit ÷ 8
Beräkning av KV-cache
Redigerbart exempel, ingen viss modell
Modellvärdenas ursprung
Redigerbart exempel, inte din dator
Ursprung för minnesvärdena
Ej angivet
Modellprofil
Ej angivet
Operativsystem
Ej angivet
Runtime
Inte tillgängligt
Jämförelse med en offentlig modellprofil

Minnesanvändning (övre gräns, %)

Ingen bedömningRymsSnävtÖverskridet

Samma modell med andra kvantiseringar

Samma modell med andra kvantiseringar
Bitar per viktVikterTotalt (övre gräns)Kvarvarande minne
16 bit14,00 GB17,76 GB-9,71 GB
8 bit7,00 GB10,06 GB-2,01 GB
6 bit5,25 GB8,14 GB-0,08 GB
5 bit4,38 GB7,17 GB0,88 GB
4 bit3,50 GB6,21 GB1,84 GB
3 bit2,63 GB5,25 GB2,80 GB
2 bit1,75 GB4,29 GB3,77 GB
Laddas min fil upp?

Nej. Allt körs i din webbläsare - din fil lämnar aldrig din enhet. Så går det att verifiera

Ingen uppladdning100% lokalt
Innehållet stannar hos digingen åtkomst för tredje part
Hostat i TysklandGlobal innehållsleverans
Granskat externtTLS A+ · HTTP-rubriker A+

Om en språkmodell kan köras lokalt avgörs först av minnet. Räknaren delar upp behovet i separata delar: vikterna (antal parametrar gånger bitar per vikt delat med 8), KV-cachen för den kontext du använder, en körbuffert och en synlig osäkerhet. Sju miljarder parametrar med 4 bitar ger 3,5 GB rena vikter innan någon overhead tillkommer. Varje storlek visas två gånger: i GB (10⁹ byte) och i GiB (2³⁰ byte), eftersom grafikkort och arbetsminne räknas binärt medan modellfiler ofta anges decimalt.

KV-cachen växer linjärt med kontexten och följer arkitekturen: två (nycklar och värden) gånger lager gånger KV-huvuden gånger huvuddimension gånger token gånger byte per element. Modeller med grouped-query attention har färre KV-huvuden än frågehuvuden och behöver därför mindre cache. För mixture-of-experts räknas det totala antalet parametrar för minnet, eftersom alla experter måste vara inlästa; de aktiva parametrarna per token avgör bara beräkningsarbetet. Tabellen visar samma modell med andra kvantiseringsnivåer, tillsammans med den största kontexten och det högsta antalet bitar som får plats helt.

Flera grafikkort räknas bara ihop om din runtime faktiskt fördelar lagren mellan dem; utan stödd uppdelning är två kort med 8 GiB vardera inte ett kort med 16 GiB. Det som inte får plats i GPU-minnet kan avlastas till arbetsminnet; resultatet anger den delen men säger ingenting om hastigheten. Inga modellprofiler är inbyggda: de förifyllda värdena är ett redigerbart exempel, inte en viss modell. Fyll i uppgifterna från modellkortet; allt beräknas i webbläsaren och sparas ingenstans.

Gratis och utan konto: räkna så ofta du vill, det du skriver stannar på din enhet.

Tekniska data

Tekniska data
IndataformatFormulärinmatning (ingen fil)
BearbetningLokalt i webbläsaren (JavaScript)
FiluppladdningIngen

I 3 steg

  1. Ange minnestyp, VRAM per GPU, antal och uppdelning av GPU:er samt arbetsminne och reserver.
  2. Ange värdena från modellkortet: parametrar, bitar per vikt, lager, KV-huvuden, huvuddimension och kontext.
  3. Läs av resultatet, fördelningen på vikter, KV-cache och buffert, avlastningen och kvantiseringsalternativen.

Begränsningar: Att minnet räcker är inget löfte om hastighet, stöd i runtimen eller drivrutiner. Körbufferten och reserverna är antaganden; runtimes behöver mer eller mindre beroende på version, batchstorlek och backend. KV-formeln gäller vanlig attention med GQA/MQA; sliding-window-, MLA- eller hybridarkitekturer kan behöva betydligt mindre cache. Inga modell- eller hårdvarudata är inbyggda.

Vanliga frågor

Hur mycket minne behöver en modells vikter?

Parametrar gånger bitar per vikt delat med 8. Sju miljarder parametrar med 4 bitar är 3,5 GB eller cirka 3,26 GiB, innan KV-cache och buffert tillkommer. Kvantiseringsformat med skalor hamnar något över sitt nominella antal bitar; ange då de effektiva bitarna (filstorlek i byte gånger 8 delat med antalet parametrar).

Varför visar räknaren både GB och GiB?

En GB är 10⁹ byte, en GiB är 2³⁰ byte, alltså ungefär 7 procent mer. Grafikkort och arbetsminne räknas binärt även när det står GB på förpackningen; modellfiler anges ofta decimalt. Båda värdena visas separat så att inget blandas ihop obemärkt.

Räknas två grafikkort med 8 GB som ett med 16 GB?

Bara om din runtime fördelar lagren på båda korten. Utan stödd uppdelning måste modellen få plats på ett kort, och räknaren räknar bara det kortets minne. Även med uppdelning behöver varje kort sin egen reserv.

Hur räknar verktyget på mixture-of-experts-modeller?

För minnet används de totala parametrarna, eftersom alla experter måste vara inlästa. De aktiva parametrarna per token visas bara; de påverkar beräkningsarbetet, inte utrymmet som behövs.

Betyder ”får plats” att modellen går snabbt?

Nej. Räknaren kontrollerar bara minnet. Hur snabbt en modell svarar beror på minnesbandbredd, beräkningskraft, runtime och avlastning. En del som ligger i arbetsminnet gör oftast utmatningen betydligt långsammare.

Är LLM-VRAM-räknare gratis och går att använda utan konto?

Ja. Det är gratis och kräver inget konto: du kan räkna så ofta du vill, och det du skriver stannar på din enhet.

Relaterade verktyg

AI-tokenräknare · Datastorlekomvandlare · Energikostnad · Jämför AI-modeller · Planera PC-uppgradering · RAM, SSD: pris per GB