Microsofts Inferensramverk för 1-Bit Stora Språkmodeller till Lokala Enheter

Den 17 oktober 2024 meddelade Microsoft BitNet.cpp, ett inferensramverk som är utformat för att köra 1-bit kvantisering Stora Språkmodeller (LLM). BitNet.cpp är ett betydande framsteg inom Gen AI, som möjliggör distributionen av 1-bit LLM effektivt på standard-CPU:er, utan att kräva dyra GPU:er. Denna utveckling demokratiserar tillgången till LLM, gör dem tillgängliga på en stor mängd enheter och ger nya möjligheter för AI-applikationer på enheten.

Att förstå 1-bit Stora Språkmodeller

Stora Språkmodeller (LLM) har traditionellt sett krävt betydande beräkningsresurser på grund av deras användning av högprecisionsflyttalsnummer (vanligtvis FP16 eller BF16) för modellvikter. Denna nödvändighet har gjort distributionen av LLM dyra och energikrävande.

I sin kärna använder 1-bit LLM extrema kvantiseringstekniker för att representera modellvikter med endast tre möjliga värden: -1, 0 och 1, därav termen “1,58-bit” (eftersom det kräver något mer än en bit för att koda tre tillstånd).

Ternär Viktssystem

Konceptet

1-bit-kvantiseringen i BitNet.cpp är ett ternärt viktssystem. BitNet fungerar med endast tre möjliga värden för varje parameter:

• -1 (negativ)
• 0 (neutral)
• 1 (positiv)

Detta resulterar i en lagringskrav på cirka 1,58 bitar per parameter, därav namnet BitNet b1,58. Denna drastiska minskning av parameterbitbredd leder till en imponerande minskning av minnesanvändning och beräkningskomplexitet, eftersom de flesta flyttalsmultiplikationer ersätts med enkla additioner och subtraktioner.

Matematisk Grund

1-bit-kvantisering innebär att vikter och aktiveringar omvandlas till deras ternära representation genom följande steg:

1. Viktbinarisering

Att binarisera vikterna innebär att centralisera dem kring medelvärdet (α), vilket resulterar i en ternär representation. Omvandlingen uttrycks matematiskt som:

Wf=Sign(W−α)

Där:

• W är den ursprungliga viktmatrixen.
• α är medelvärdet av vikterna.
• Sign(x) returnerar +1 om x > 0 och -1 annars.

2. Aktiveringskvantisering

Att kvantisera aktiveringar säkerställer att indata är begränsade till en specificerad bitbredd:

x^e=Quant(x)=Clip(γx×Qb​​,−Qb+ϵ,Qb−ϵ)

Där:

• Qb = 2(b−1)2^{(b-1)}2(b−1) är den maximala kvantiseringen för b-bitbredd.
• γ är det maximala absoluta värdet av x (betecknat som ∣∣x∣∣∞​).
• ε är ett litet tal för att förhindra överflöd under beräkningar.

3. BitLinear Operation

BitLinear-lagret ersätter traditionella matrismultiplikationer med en förenklad operation:

y=Wf×x^e×(Qb​βγ​)

Där:

• β är en skalfaktor som används för att minimera approximeringsfel.
• γ skalar aktiveringarna.
• Q_b är kvantiseringsfaktorn.

Denna transformation möjliggör effektiva beräkningar samtidigt som modellprestandan bevaras.

Prestandaimplikationer

Minneseffektivitet

Det ternära viktssystemet minskar minneskraven avsevärt:

• Traditionella LLM: 16 bitar per vikt
• BitNet.cpp: 1,58 bitar per vikt

Denna minskning översätts till en minnessparande på cirka 90% jämfört med traditionella 16-bitarsmodeller, vilket gör att större modeller kan placeras inom samma hårdvarubegränsningar.

Inferences hastighet, Energieffektivitet (Apple M2)

Inferences hastighet, Energieffektivitet (i7-13700H)

1. Inferences hastighet: Snabbare på båda CPU:er

Inferences hastighet representeras som antalet token som bearbetas per sekund. Här är en sammanfattning av observationerna:

• På Apple M2 Ultra: BitNet.cpp uppnår upp till 5,07x hastighetsökning för större modeller (30B) jämfört med Llama.cpp, med en topphastighet på 593,43 token per sekund för en 125M-modell, vilket är en 1,37x hastighetsökning. För större modeller som 3,8B och 7B upprätthåller BitNet.cpp en hastighet över 84,77 token per sekund, vilket visar dess effektivitet över skalor.
• På Intel i7-13700H: BitNet.cpp uppnår ännu mer dramatiska hastighetsförbättringar. Vid 7B-modellstorlek levererar BitNet.cpp en fantastisk 5,68x hastighetsökning jämfört med Llama.cpp. För mindre modeller som 125M bearbetar det 389,08 token per sekund, vilket är 2,37x snabbare än Llama.cpp.

2. Energieffektivitet: En spelväxlare för Edge-enheter

De tillhandahållna graferna innehåller också energikostnadsjämförelser, som visar en betydande minskning av energiförbrukning per token som bearbetas:

• På Apple M2 Ultra: BitNet.cpp:s energibesparingar är betydande. För 700M-modellen förbrukar det 55,4% mindre energi per token jämfört med Llama.cpp, från 0,314 till 0,140. Denna trend fortsätter för större modeller, med 70B-modellen som visar en 70,0% minskning av energiförbrukning.
• På Intel i7-13700H: BitNet.cpp levererar 71,9% energibesparing för 700M-modellen, med en förbrukning som minskar från 1,367 till 0,384. Även om energidata för 70B-modellen i Llama.cpp inte är tillgänglig, förblir BitNet.cpp effektivt, med en energiförbrukning på 17,33 för 70B-modellen.

3. Att korsa mänsklig läshastighetsgränsen

En av de mest intressanta insikterna från dessa grafer är referensen till mänsklig läshastighet, markerad vid 5-7 token per sekund. Denna röda linje visar att båda implementationerna, särskilt BitNet.cpp, kan bekvämt överträffa mänsklig läshastighet även för de största modellerna:

• På Apple M2 Ultra överträffar BitNet.cpp mänsklig läshastighet för alla modellstorlekar, med den lägsta hastigheten på 8,67 token per sekund för en 70B-modell.
• På Intel i7-13700H uppnår 100B-modellen 1,70 token per sekund, nästan i den nedre delen av mänsklig läshastighet, medan alla mindre modeller överträffar denna gräns.

Träningsöverväganden

Straight-Through Estimator (STE)

Eftersom 1-bit-kvantisering introducerar icke-differentierbara funktioner, involverar träningsprocessen en specialteknik som kallas Straight-Through Estimator (STE). I detta tillvägagångssätt flödar gradienterna oförändrade genom icke-differentierbara punkter. Här är en förenklad implementering i Python:

class StraightThroughEstimator(Function):
@staticmethod
def forward(ctx, input):
return input.sign()

@staticmethod
def backward(ctx, grad_output):
return grad_output

Blandad precisionsträning

För att upprätthålla stabilitet under träningsprocessen används blandad precision:

• Vikter och aktiveringar: Kvantiseras till 1-bit precision.
• Gradients och optimeringslägen: Lagras i högre precision.
• Latenta vikter: Underhålls i hög precision för att möjliggöra exakta uppdateringar under träningsprocessen.

Stor inlärningshastighetsstrategi

En unik utmaning med 1-bit-modeller är att små uppdateringar kanske inte påverkar binära vikterna. För att mildra detta ökas inlärningshastigheten, vilket säkerställer snabbare konvergens och bättre optimering jämfört med traditionella tillvägagångssätt.

Gruppkvantisering och normalisering

BitNet.cpp introducerar gruppkvantisering och normalisering för att förbättra modellparallellism. Istället för att beräkna parametrar för hela viktmatrixen delar BitNet vikter och aktiveringar i flera grupper (G).

Denna gruppering möjliggör effektiv parallellbearbetning utan ytterligare gruppinteraktion, vilket möjliggör storskalig modellträning och inferens.

Implementeringsanteckningar och optimeringar

CPU-optimering

BitNet.cpp utnyttjar flera lågnivåoptimeringar för att uppnå topp-CPU-prestanda:

• Vecktoriserade operationer: Utnyttjar SIMD-instruktioner för att utföra bitmanipulationer effektivt.
• Cache-vänlig minnesåtkomst: Strukturerar data för att minimera cache-missar.
• Parallell bearbetning: Distribuerar arbetsbelastningen effektivt över flera CPU-kärnor.

Här är ett exempel på en nyckelfunktion som implementerar kvantisering och inferens i BitNet:

Förklaring:

• -m specificerar modellfilens sökväg.
• -p definierar prompttexten.
• -n ställer in antalet token som ska förutsägas.
• -temp justerar samplingens slumpmässighet (temperatur) under inferens.

Exempel på utdata

Tekniska detaljer om BitNet.cpp

BitLinear-lager

BitNet.cpp implementerar en modifierad Transformer-arkitektur, som ersätter standardmatrismultiplikationer med BitLinear-operationer. Detta tillvägagångssätt centraliserar vikterna kring noll innan kvantisering och skalar dem för att minimera approximeringsfel. Den viktigaste transformationsfunktionen ser ut så här:

# Binarisera vikter för 1-bit-vikter
def binarize_weights(W):
alpha = W.mean()
W_binarized = np.sign(W - alpha)
return W_binarized

Kombinationen av centraliserade vikter och skalfaktor säkerställer att kvantiseringsfelet förblir minimalt, vilket bevarar prestandan.

Branschpåverkan

BitNet.cpp kan ha långtgående implikationer för distributionen av LLM:

• Tillgänglighet: Tillåter LLM att köras på standardenheter, vilket demokratiserar tillgången till kraftfull AI.
• Kostnadseffektivitet: Minskar behovet av dyra GPU:er, vilket sänker tröskeln för antagande.
• Energieffektivitet: Sparar energi genom att utnyttja standard-CPU-baserad inferens.
• Innovation: Öppnar nya möjligheter för AI-applikationer på enheten, som realtidsöversättning, röstassistenter och ansvarsfulla applikationer utan molnberoenden.

Utlagningar och framtida riktningar

Medan 1-bit LLM har potential, kvarstår flera utmaningar. Dessa inkluderar utvecklingen av robusta 1-bit-modeller för olika uppgifter, optimering av hårdvara för 1-bit-beräkning och uppmuntran av utvecklare att anta denna nya paradigm. Dessutom är att utforska 1-bit-kvantisering för datorseende eller ljuduppgifter en spännande framtida riktning.

Slutsats

Microsofts lansering av BitNet.cpp är ett betydande framsteg. Genom att möjliggöra effektiv 1-bit-inferens på standard-CPU:er skapar BitNet.cpp tillgänglighet och hållbarhet för AI. Detta ramverk sätter scenen för mer bärbara och kostnadseffektiva LLM, vilket driver vad som är möjligt med AI på enheten.