Hoppa till innehållet
POLARISAI ACADEMY
R08-101 · Navigatör

Köra AI lokalt: hårdvara, kvantisering och motorer

Efteråt kan du addera viktbyte, KV-cache, scratch och en fast reserv för motorn för en given modell, runda en vikt till ett INT4-rutnät, och kolla att en lokal server ger samma text två gånger när temperaturen är 0.

Nivå
Navigatör
Tid
22 h (uppskattning)
Förkunskap
F01–F07, R02-101
Kurs 1 av 4
Hoppa till

Efter kursen kan du

Eleven kan beräkna exakta minneskrav för VRAM och KV-cache för valfri modellarkitektur och kvantiseringsnivå och konfigurera en lokal inferensserver offline som klarar tester av API-kontrakt och determinism.

Licensfilen bredvid vikterna

Open-weight betyder att viktfilen går att ladda ner och köra på din egen maskin. Licensfilen i samma mapp är regeln för den kopia du har. Två vanliga texter är Apache-2.0 och MIT. En community-licens är en ytterligare text som utgivaren av just den filen har skrivit, och den kan lägga till ett tak som de andra två saknar. Du följer filen som följde med vikterna. En etikett på en nedladdningssida blir en regel först när du öppnar den texten.

Apache-2.0 ger en upphovsrättslicens att använda, kopiera, ändra och sprida vikterna, också inuti en produkt du säljer. Texten har också en patentlicens från varje bidragsgivare för just det bidraget. När du skickar en kopia vidare ska Apache-2.0-texten följa med, attributionsraderna i NOTICE ska vara kvar, och filer du ändrat ska märkas. Licensen lämnar utgivarens varumärke hos utgivaren. En genomgången mapp har tre filer: weights.gguf, LICENSE med Apache-2.0-texten, och NOTICE med raden Copyright 2024 North Workshop. Att kopiera mappen till en andra maskin är tillåtet när LICENSE och NOTICE följer med vikterna. MIT ger lov att använda, kopiera, ändra, slå ihop, publicera, sprida, underlicensiera och sälja, och copyright-raden plus tillståndsraden ska följa med varje kopia eller väsentlig del. MIT-texten har inget patentavsnitt. Community-Local är en licens som bara finns i den här lektionen, så att taket är ett tal du kan kontrollera. Lokal körning, ändring och att ge bort kopior är tillåtet när licensfilen följer med. En värdtjänst är tillåten upp till 100 olika användare under en månad. Användare 101 samma månad kräver ett särskilt skriftligt avtal. Apache-2.0 och MIT sätter, som de texterna är skrivna, inget tak på antalet användare.

Fyra termer som fyller VRAM

VRAM är minnet på kortet. Där ska vikterna och arbetsminnet för svaret rymmas. I lektionen är 1 MiB lika med 2^20 byte, alltså 1 048 576 byte, och 1 GiB är 1024 MiB. Modell A har N = 2^31 parametrar, utskrivet 2 147 483 648. Den har L = 24 lager, n_kv = 8 nyckel-värde-huvuden, d_head = 64 och d_model = 2048. Den genomräknade sekvenslängden är S = 1024 token, och batchen är B = 1. Viktbyte är N gånger de byte som lagras per vikt: 2 för FP16, 2 för BF16, 1 för INT8 och 1/2 för rena INT4-koder. FP16 och BF16 ger båda 2 147 483 648 gånger 2 = 4 294 967 296 byte, alltså 4 GiB, eller 4096 MiB. Antalet byte är detsamma. Upplägget skiljer sig: FP16 använder 5 exponentbitar och 10 bråkbitar, plus en teckenbit, medan BF16 använder 8 exponentbitar och 7 bråkbitar, plus en teckenbit.

KV-cachen lagrar en nyckelvektor och en värdevektor för varje lager och varje token som fortfarande ligger i sekvensen. Storleken är 2 gånger L gånger n_kv gånger d_head gånger bytes_act gånger S. Med bytes_act = 2 blir produkten 2 gånger 24 gånger 8 gånger 64 gånger 2 gånger 1024 = 50 331 648 byte = 48 MiB. Scratch-byte är de två levande aktiveringsbuffertarna i lektionens bokföring: B gånger S gånger d_model gånger bytes_act gånger 2 = 1 gånger 1024 gånger 2048 gånger 2 gånger 2 = 8 388 608 byte = 8 MiB. Motorreserven är fasta 512 MiB för motorns eget sammanhang. Addera de fyra termerna för FP16: 4096 + 48 + 8 + 512 = 4664 MiB. Rena INT8-vikter, med samma FP16-cache och scratch, ger 2048 + 48 + 8 + 512 = 2616 MiB. Rena INT4-vikter ger 1024 + 48 + 8 + 512 = 1592 MiB. Höj S från 1024 till 2048 så dubblas både cachen och scratch, till 96 MiB och 16 MiB, eftersom båda termerna är linjära i S. Vikttermen och reserven på 512 MiB ligger kvar. Ren INT4 vid S = 2048 är 1024 + 96 + 16 + 512 = 1648 MiB.

Kvantiseringsrutnät och tre packningar

Kvantisering (quantization) lagrar varje vikt som en kod på ett grovt rutnät och multiplicerar koden med en skala när modellen kör. På lektionens symmetriska INT4-rutnät går koderna från -7 till 7 och skalan är s = 0,05. Dela vikten med s, ta närmaste heltal, och klipp allt över 7 eller under -7 till rutnätets ände. När decimaldelen är 0,5 eller större rundar du till det heltal som ligger längre från noll. De fyra vikterna 0,20, 0,27, 0,13 och 0,05 landar så här. 0,20/0,05 = 4 exakt, lagras som 0,20, absolutfel 0. 0,27/0,05 = 5,4, rundas till 5 och lagras som 0,25, absolutfel 0,02. 0,13/0,05 = 2,6, rundas till 3 och lagras som 0,15, absolutfel 0,02. 0,05/0,05 = 1 exakt, lagras som 0,05, absolutfel 0. Medelabsolutfelet är 0,04/4 = 0,01. Vikten 0,50 ger 0,50/0,05 = 10, klipps till 7, lagras som 0,35, absolutfel 0,15. Vikten 0,33 ger 0,33/0,05 = 6,6, rundas till 7 och lagras som 0,35, absolutfel 0,02. I en kontroll med fyra positioner är sannolikheten för den sanna nästa token 1/2, 1/2, 1/4 och 1/4. Bitkostnaden är medelvärdet av de negativa tvålogaritmerna: 1, 1, 2 och 2, så medelvärdet är 1,5 bitar. Efter det grövre rutnätet är sannolikheterna 1/2, 1/4, 1/4 och 1/8, kostnaderna är 1, 2, 2 och 3, och medelvärdet är 2,0 bitar. Ökningen på den filen är 0,5 bitar per token. Sannolikheterna är valda så att varje logaritm blir ett heltal.

GGUF är en fil som lagrar de kvantiserade tensorerna och ett huvud med L, n_kv, d_head, d_model och N. Ett Q4_0-block rymmer 32 fyrabitars koder och en skala på 2 byte. Skalan lägger till 2/32 = 1/16 byte per vikt. För modell A är tillägget 2 147 483 648/32 gånger 2 = 134 217 728 byte = 128 MiB, så Q4_0-vikttermen är 1024 + 128 = 1152 MiB. Fyratermssumman med den vikttermen, vid S = 1024, är 1152 + 48 + 8 + 512 = 1720 MiB. AWQ, activation-aware weight quantization, lägger fortfarande ungefär 4 bitar på varje vikt, och siktar rutnätet mot kanaler vars aktiveringar är stora. Ta w = 0,13 och en aktivering på 10. Den sanna produkten är 1,30. Det enkla rutnätet lagrar 0,15, produkten blir 1,50 och felet är 0,20. Multiplicera vikten med alfa = 2 före rutnätet: 0,26/0,05 = 5,2, som rundas till 5 och lagrar 0,25. Dela med alfa efteråt så blir vikten 0,125. Produkten blir 1,25, och felet sjunker till 0,05. En packning som delar en skala på 2 byte över 128 vikter lägger till 2 147 483 648/128 gånger 2 = 33 554 432 byte = 32 MiB, så den vikttermen är 1024 + 32 = 1056 MiB. EXL2 väljer en bitbredd per lager så att medelvärdet träffar ett mål. Dela modell A i två halvor om 2^30 parametrar var. En halva på 8 bitar och en halva på 4 bitar använder 2^30 gånger 1 byte plus 2^30 gånger 1/2 byte = 1,5 GiB = 1536 MiB koder, och medelvärdet är 6 bitar per vikt.

Bandbredd, watt och tokentaket

När fyratermssumman ryms på kortet begränsas en ensam ström av hur fort kortet kan läsa vikterna. Lektionens avkodningstak vid batch 1 är levererad bandbredd delad med viktstorleken, och KV- och scratch-läsningarna räknas som små bredvid vikterna. Kort C levererar 400 GiB/s och har ett effekttak på 200 W. FP16-vikter är 4 GiB, så taket är 400/4 = 100 token per sekund. Rena INT4-vikter är 1 GiB, så taket är 400/1 = 400 token per sekund. Lektionens effektantagande är att levererad bandbredd skalas med effektkvoten när taket sänks. Ett tak på 150 W är 150/200 = 0,75 av märkeffekten, så bandbredden blir 300 GiB/s. FP16-taket faller till 300/4 = 75 token per sekund. Det rena INT4-taket faller till 300/1 = 300 token per sekund. En timme vid 200 W drar 0,2 kWh. En timme vid 150 W drar 0,15 kWh. Kylaren ska flytta de watten ut i rummet. När kylaren halkar efter lägger kortet sig på det lägre taket, och tokentaket faller med bandbredden.

En server som batchar läser vikterna en gång per steg för hela batchen. Vid batch 4 bär den FP16-läsning som bar 100 token per sekund på en ström i stället 400 token per sekund tillsammans över de fyra strömmarna, vid siffran 400 GiB/s. Varje ström behåller sin egen KV-cache, så cachetermen blir 4 gånger 48 MiB = 192 MiB vid S = 1024, medan vikterna ligger kvar som en kopia. Scratch följer också B och blir 4 gånger 8 MiB = 32 MiB. FP16-summan vid batch 4 är 4096 + 192 + 32 + 512 = 4832 MiB. Kort C har i det genomräknade fallet 8192 MiB VRAM. Den rena INT4-summan vid batch 1, 1592 MiB, lämnar 8192 - 1592 = 6600 MiB fria. FP16-summan vid batch 1, 4664 MiB, lämnar 8192 - 4664 = 3528 MiB fria.

Tre lokala motorer och ett stabilitetstest

När filerna ligger på disk kan modell A serveras utan en ny nedladdning. Ollama, en körare med ett kommando, lägger viktfilen i sitt eget lager och lyssnar på 127.0.0.1 port 11434. GGUF-motorn på kommandoraden tar sökvägen till en .gguf-fil och kontextlängden, och den kan öppna en port på samma maskin. vLLM är en server som samlar flera förfrågningar i samma steg så att de delar en läsning av vikterna, alltså fallet med batch 4 ovan, och den vanliga porten är 8000. Alla tre kan svara på en lokal förfrågan som bär en prompt, en temperatur och högst 16 nya token. När vikterna redan är lokala svarar en container som startats med nätet avstängt ändå, eftersom svaret räknas fram ur filen på disk.

Stabilitetstestet skickar samma prompt två gånger. Vid temperatur 0 behåller varje steg den enda högsta token, så de två svarssträngarna blir lika på samma fil och samma bygge. Vid temperatur 0,7 väljer seed dragningen: två anrop med seed 7 blir lika, och ett anrop med seed 8 kan lämna den texten. Du jämför strängarna själv. En träff vid temperatur 0 stöder att det här bygget, den här filen och den här prompten ligger stilla. En miss vid temperatur 0 betyder att motorn fortfarande samplar, eller att filen eller bygget ändrades mellan de två anropen.

Ett exempel

Modell A på kort C, ren INT4, för hand

Kort C har 8192 MiB VRAM, levererar 400 GiB/s och har taket 200 W. Ladda modell A som rena INT4-vikter med FP16-KV-cache och FP16-scratch, S = 1024, B = 1. Viktbyte: 2 147 483 648 gånger 1/2 = 1 073 741 824 byte = 1024 MiB. KV-cache: 50 331 648 byte = 48 MiB. Scratch: 8 388 608 byte = 8 MiB. Motorreserv: 512 MiB. Summan är 1024 + 48 + 8 + 512 = 1592 MiB. Ledigt minne är 8192 - 1592 = 6600 MiB, så filen ryms. Taket vid batch 1 är 400 GiB/s delat med 1 GiB = 400 token per sekund.

Samma kort med FP16-vikter använder 4096 + 48 + 8 + 512 = 4664 MiB och lämnar 8192 - 4664 = 3528 MiB fria. Taket sjunker till 400/4 = 100 token per sekund eftersom varje ny token läser 4 GiB. Mappen bredvid de vikterna har en Apache-2.0-LICENSE och en NOTICE-rad, Copyright 2024 North Workshop. En kopia på en andra maskin behåller båda filerna, och en ändrad kvantiseringskonfiguration märks i filen du ändrade. Community-Local är en annan text: vid 100 användare under en månad ligger värdtjänsten inom taket, och vid 150 användare krävs ett särskilt skriftligt avtal.

Övning

Kolla på papper

Med modell A och lektionens fyra termer, skriv den rena INT8-summan i MiB vid S = 1024 och B = 1. Skriv den rena INT4-summan vid S = 2048. Skriv Q4_0-vikttermen och Q4_0-fyratermssumman vid S = 1024. Runda vikten 0,33 på rutnätet s = 0,05 och ange lagrat värde och absolutfel. Ange FP16-taket vid batch 1 i token per sekund när kort C är sänkt till 300 GiB/s, och det sammanlagda FP16-taket vid batch 4 när kortet fortfarande levererar 400 GiB/s. Säg vad Community-Local kräver vid 150 olika användare under en månad. Ange medelbitkostnaden, i bitar, för de grövre fyra sannolikheterna 1/2, 1/4, 1/4 och 1/8.

Den rena INT8-summan är 2048 + 48 + 8 + 512 = 2616 MiB. Den rena INT4-summan vid S = 2048 är 1024 + 96 + 16 + 512 = 1648 MiB. Q4_0-vikttermen är 1152 MiB, och fyratermssumman är 1152 + 48 + 8 + 512 = 1720 MiB. Vikten 0,33 blir 0,33/0,05 = 6,6, rundas till 7 och lagras som 0,35, med absolutfel 0,02. FP16-taket vid 300 GiB/s är 75 token per sekund, och det sammanlagda taket vid batch 4 och 400 GiB/s är 400 token per sekund. Community-Local kräver ett särskilt skriftligt avtal vid 150 användare, eftersom taket är 100. Den grövre medelbitkostnaden är 2,0 bitar.

Kontrollfrågor

Svara själv först. Öppna sedan frågan för att se svaret.

Vilken är den rena INT4-fyratermssumman för modell A vid S = 1024 och B = 1, i MiB, och vilka fyra tal adderas?

1592 MiB, av 1024 MiB vikter, 48 MiB KV-cache, 8 MiB scratch och 512 MiB motorreserv.

Varför tar FP16-vikterna och BF16-vikterna i modell A båda 4096 MiB, och hur många exponentbitar har varje upplägg?

Båda lagrar 2 byte per parameter, så båda är 4 GiB. FP16 använder 5 exponentbitar. BF16 använder 8 exponentbitar.

Hur många MiB lägger Q4_0-skalorna till för modell A, och vilken är fyratermssumman vid S = 1024 när vikttermen inkluderar de skalorna?

Skalorna lägger till 128 MiB. Vikttermen är 1152 MiB, och fyratermssumman är 1720 MiB.

Varför ger två anrop vid temperatur 0 samma text, och vilket är FP16-tokentaket vid batch 1 på kort C vid 400 GiB/s?

Varje steg behåller den enda högsta token, så strängarna blir lika på samma fil och bygge. Taket är 100 token per sekund.

Ta med dig

Modellen ryms när fyratermssumman ligger inom kortets MiB, farten på en ström är levererade GiB/s delat med viktens GiB, och licensfilen bredvid vikterna är regeln för en andra kopia eller en värdtjänst.

Slutuppgift

Klara ett nycklat beräkningsbenchmark med 25 poster för VRAM, bandbredd och kvantisering, och lämna in en lokal inferenskonfiguration och ett benchmarkskript som klarar 20 automatiserade tester i en container utan nätverk (--network=none) med en liten fixture-modell.

Slutuppgiften rättas av fasta facit och automatiska tester när proven öppnar.

Begrepp i kursen

Kursen har inga egna begrepp i ordlistan ännu. Begrepp från tidigare kurser används här också.

Fler lektioner kommer

Första lektionen är öppen att läsa. Resten av kursens lektioner skrivs, och prov och diplom kommer senare. Till väntelistan