Microsofts Inferensramverk För 1-Bit Stora Språkmodeller Till Lokala Enheter

Den 17 oktober 2024 meddelade Microsoft (MSFT ) BitNet.cpp, ett inferensramverk designat för att köra 1-bit kvantiserade stora språkmodeller (LLM). BitNet.cpp är ett betydande steg framåt i Gen AI, som möjliggör distribution av 1-bit LLM effektivt på standard-CPU, utan att kräva dyra GPU. Denna utveckling demokratiserar tillgången till LLM, gör dem tillgängliga på en mängd olika enheter och skapar nya möjligheter för AI-applikationer på enheten.

Förstå 1-Bit Stora Språkmodeller

Stora språkmodeller (LLM) har traditionellt krävt betydande beräkningsresurser på grund av deras användning av högprecisions flyttalsnummer (vanligtvis FP16 eller BF16) för modellvikter. Detta behov har gjort distributionen av LLM dyra och energikrävande.

Till sin kärna använder 1-bit LLM extrem kvantiseringsteknik 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 kvantisering 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 omvandla vikter och aktiveringar till deras ternära representation genom följande steg:

1. Viktbinarisering

Binarisering av vikterna innebär att centralisera dem runt 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

Kvantisering av 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 kvantiseringsnivån för b-bit bredd.
• γ är det maximala absoluta värdet av x (betecknat som ∣∣x∣∣∞​).
• ε är ett litet tal för att förhindra översvämning under beräkningar.

3. BitLinjär Operation

BitLinjär skiktet ersätter traditionella matrismultiplikationer med en förenklad operation:

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

Där:

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

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

Prestandaimplikationer

Minneseffektivitet

Det ternära viktssystemet minskar avsevärt minneskraven:

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

Denna minskning motsvarar en minnessparande på cirka 90% jämfört med traditionella 16-bitarsmodeller, vilket möjliggör större modeller att passa inom samma hårdvarukonstruktioner.

Inferencesnabbhet, Energieffektivitet (Apple [securities_stock_price_tag symbol="AAPL" exchange="NASDAQ"] M2)

Inferencesnabbhet, Energieffektivitet (i7-13700H)

1. Inferencesnabbhet: Snabbare på båda CPU

Inferencesnabbhet 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 snabbare inferencesnabbhet för större modeller (30B) jämfört med Llama.cpp, med en toppsnabbhet på 593,43 token per sekund för en 125M-modell, vilket är en 1,37x snabbare inferencesnabbhet. För större modeller som 3,8B och 7B upprätthåller BitNet.cpp en snabbhet över 84,77 token per sekund, vilket visar dess effektivitet över olika skalor.
• På Intel (INTC ) i7-13700H: BitNet.cpp uppnår ännu mer dramatiska inferencesnabbhetsförbättringar. Vid 7B-modellstorlek levererar BitNet.cpp en otrolig 5,68x snabbare inferencesnabbhet 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 minskning av energiförbrukning 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. Överskridande av mänsklig läshastighetsmätning

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 överskrida mänsklig läshastighet även för de största modellerna:

• På Apple M2 Ultra överskrider 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 vid den nedre gränsen för mänsklig läshastighet, medan alla mindre modeller överskrider denna mätning.

Träningsöverväganden

Rakt Genom Estimator (STE)

Eftersom 1-bit kvantisering introducerar icke-differentierbara funktioner, involverar träningsprocessen en specialiserad teknik som kallas Rakt Genom Estimator (STE). I detta tillvägagångssätt flyter gradienterna obehindrat genom icke-differentierbara punkter. Här är en förenklad implementering i Python:

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

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

Blandad Precisionsutbildning

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

• Vikter och Aktiveringar: Kvantiserade till 1-bit precision.
• Gradients och Optimizer-tillstånd: Lagrade i högre precision.
• Latenta Vikter: Underhållna i hög precision för att möjliggöra precisa uppdateringar under utbildning.

Stor Inlärningshastighetsstrategi

En unik utmaning med 1-bit modeller är att små uppdateringar kanske inte påverkar de binariserade 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.

Grupp Kvantisering och Normalisering

BitNet.cpp introducerar Grupp Kvantisering 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 extra grupp-kommunikation, vilket möjliggör storskalig modellutbildning och inferens.

Implementeringsanteckningar och Optimeringar

CPU-optimering

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

• VEktoriserade Operationer: Använder SIMD-instruktioner för att utföra bitmanipulationer effektivt.
• Cachvänlig Minnesåtkomst: Strukturerar data för att minimera cache-missar.
• Parallell Bearbetning: Distribuerar arbetsbelastningen över flera CPU-kärnor effektivt.

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

def bitlinjär_forward(input, vikt, skala):
# Kvantiserar indata med hjälp av absolutmax-kvantisering
input_q = kvantisera(input)

# Utför binär matrismultiplikation
output = binär_matmul(input_q, vikt)

# Skalar utdata för att matcha ursprunglig precision
return output * skala

def kvantisera(x):
# Utför absolutmax-kvantisering
skala = torch.max(torch.abs(x))
return torch.clamp(x / skala, -1, 1) * skala

# Binariseringsfunktion för 1-bit vikter
def binarisera_vikter(W):
alpha = W.mean()
W_binariserad = np.sign(W - alpha)
return W_binariserad