Microsofts Inference Framework bringer 1-bit store sprogmodeller til lokale enheder

I oktober 17, 2024, Microsoft annoncerede BitNet.cpp, en slutningsramme designet til at køre 1-bit kvantiserede store sprogmodeller (LLM'er). BitNet.cpp er et betydeligt fremskridt inden for Gen AI, der muliggør implementering af 1-bit LLM'er effektivt på standard-CPU'er uden at kræve dyre GPU'er. Denne udvikling demokratiserer adgangen til LLM'er, gør dem tilgængelige på en bred vifte af enheder og giver nye muligheder inden for AI-applikationer på enheden.

Forståelse af 1-bit store sprogmodeller

Store sprogmodeller (LLM'er) har traditionelt krævet betydelige beregningsressourcer på grund af deres brug af højpræcise flydende kommatal (typisk FP16 eller BF16) til modelvægte. Denne nødvendighed har gjort implementeringen af ​​LLM'er dyr og energikrævende.

I deres kerne bruger 1-bit LLM'er ekstreme kvantiseringsteknikker til at repræsentere modelvægte med kun tre mulige værdier: -1, 0 og 1, deraf udtrykket "1.58-bit" (da det kræver lidt mere end én bit at kode tre stater).

Ternært vægtsystem

Konceptet

1-bit kvantiseringen i BitNet.cpp er et ternært vægtsystem. BitNet fungerer med kun tre mulige værdier for hver parameter:

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

Dette resulterer i et lagerkrav på omkring 1.58 bit pr. parameter, deraf navnet BitNet b1.58. Denne drastiske reduktion i parameterbitbredden fører til en imponerende reduktion i hukommelsesforbrug og beregningsmæssig kompleksitet, da de fleste flydende kommamultiplikationer erstattes med simple additioner og subtraktioner.

Matematisk Fond

1-bit kvantisering involverer transformation af vægte og aktiveringer til deres ternære repræsentation gennem følgende trin:

1. Vægt binarisering

Binarisering af vægtene involverer at centralisere dem omkring middelværdien (α), hvilket resulterer i en ternær repræsentation. Transformationen er matematisk udtrykt som:

Wfâ € <=Tilmeld(W-α)

Hvor:

• W er den oprindelige vægtmatrix.
• α er middelværdien af ​​vægtene.
• Tegn (x) afkast +1 if x > 0 og -1 Ellers.

2. Aktivering Kvantisering

Kvantiseringsaktiveringer sikrer, at input er begrænset til en specificeret bitbredde:

x^eâ € <=Quant(x)=Clip(γx×Qbâ € <â € <,-Qbâ € <+ϵ,Qbâ € <-ϵ)

Hvor:

• Qb = 2(b−1)2^{(b-1)}2(b-1) er det maksimale kvantiseringsniveau for b-bit bredde.
• γ er den maksimale absolutte værdi af x (betegnet som ∣∣x∣∣∞â € <).
• ε er et lille tal for at forhindre overløb under beregninger.

3. BitLineær drift

Det bitlineære lag erstatter traditionelle matrixmultiplikationer med en forenklet operation:

y=Wfâ € <×x^eâ € <×(Qbâ € <βγâ € <)

Hvor:

• β er en skaleringsfaktor, der bruges til at minimere tilnærmelsesfejl.
• γ skalerer aktiveringerne.
• Q_b er kvantiseringsfaktoren.

Denne transformation muliggør effektive beregninger, samtidig med at modellens ydeevne bevares.

Implikationer af ydeevne

Hukommelseseffektivitet

Det ternære vægtsystem reducerer hukommelseskravene betydeligt:

• Traditionelle LLM'er: 16 bits pr. vægt
• BitNet.cpp: 1.58 bits pr. vægt

Denne reduktion oversættes til en hukommelsesbesparelse på ca 90% sammenlignet med traditionelle 16-bit modeller, hvilket gør det muligt for større modeller at passe inden for de samme hardware begrænsninger.

Inferenshastighed, energieffektivitet (Apple M2)

Inferenshastighed, energieffektivitet (i7-13700H)

1. Inferenshastighed: Hurtigere på begge CPU'er

Inferenshastighed er repræsenteret som antallet af behandlede tokens pr. sekund. Her er en oversigt over observationerne:

• På Apple M2 Ultra: BitNet.cpp opnår op til 5.07x speedup for større modeller (30B) sammenlignet med Llama.cpp, med en tophastighed på 593.43 tokens i sekundet for en 125M model, som er en 1.37x fremskynde. For større modeller som 3.8B og 7B opretholder BitNet.cpp en hastighed på over 84.77 tokens i sekundet, hvilket viser dens effektivitet på tværs af skalaer.
• På Intel i7-13700H: BitNet.cpp opnår endnu mere dramatiske hastighedsforbedringer. Ved 7B modelstørrelsen leverer BitNet.cpp en utrolig 5.68x speedup sammenlignet med Llama.cpp. For mindre modeller som 125M behandler den 389.08 tokens i sekundet, Hvilket er 2.37x hurtigere end Llama.cpp.

2. Energieffektivitet: En Game Changer for Edge-enheder

De medfølgende grafer omfatter også sammenligning af energiomkostninger, som viser en betydelig reduktion i energiforbrug pr. behandlet token:

• På Apple M2 Ultra: BitNet.cpps energibesparelser er betydelige. For 700M-modellen forbruger den 55.4% mindre energi per token sammenlignet med Llama.cpp, falder fra 0.314 til 0.140. Denne tendens fortsætter for større modeller, hvor 70B-modellen viser en 70.0 % reduktion i energiforbruget.
• På Intel i7-13700H: BitNet.cpp leverer 71.9% energibesparelse for 700M modellen, hvor forbruget falder fra 1.367 til 0.384. Selvom energidata for 70B-modellen i Llama.cpp ikke er tilgængelige, forbliver BitNet.cpp effektiv med energiforbrug på ca. 17.33 til 70B-modellen.

3. At krydse menneskelig læsehastigheds benchmark

En af de mest interessante indsigter fra disse grafer er henvisningen til menneskelig læsehastighed, markeret kl 5-7 tokens i sekundet. Denne røde linje viser, at begge implementeringer, især BitNet.cpp, komfortabelt kan overgå menneskelige læsehastigheder selv for de største modeller:

• On Apple M2 Ultra, BitNet.cpp overgår menneskelig læsehastighed for alle modelstørrelser, med den laveste hastighed 8.67 tokens i sekundet for en 70B model.
• On Intel i7-13700H, opnår 100B-modellen stadig 1.70 tokens i sekundet, næsten ved at røre det lavere område af menneskelig læsehastighed, mens alle mindre modeller overgår dette benchmark.

Træningsovervejelser

Straight-Through Estimator (STE)

Da 1-bit kvantisering introducerer ikke-differentierbare funktioner, involverer træning en specialiseret teknik kendt som Straight-Through Estimator (STE). I denne tilgang flyder gradienterne uændret gennem ikke-differentierbare punkter. Her er en forenklet implementering i Python:

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

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

Blandet præcisionstræning

For at bevare stabiliteten under træning, blandet præcision er ansat:

• Vægte og aktiveringer: Kvantiseret til 1-bit præcision.
• Gradienter og optimeringstilstande: Lagret med højere præcision.
• Latente vægte: Opretholdt i høj præcision for at lette nøjagtige opdateringer under træning.

Strategi for stor indlæringsrate

En unik udfordring med 1-bit modeller er, at små opdateringer muligvis ikke påvirker de binariserede vægte. For at afbøde dette øges indlæringshastigheden, hvilket sikrer hurtigere konvergens og bedre optimering sammenlignet med traditionelle tilgange.

Gruppekvantisering og -normalisering

BitNet.cpp introducerer Gruppekvantisering og -normalisering at øge modelparallelismen. I stedet for at beregne parametre for hele vægtmatricen opdeler BitNet vægte og aktiveringer i flere grupper (G).â € <

Denne gruppering muliggør effektiv parallel behandling uden yderligere kommunikation mellem grupper, hvilket muliggør modeltræning og konklusioner i stor skala.

Implementeringsnoter og optimeringer

CPU optimering

BitNet.cpp udnytter adskillige optimeringer på lavt niveau for at opnå maksimal CPU-ydeevne:

• Vektoriserede operationer: Bruger SIMD-instruktioner til at udføre bitmanipulationer effektivt.
• Cache-venlig hukommelsesadgang: Strukturerer data for at minimere cache-misser.
• Parallelbehandling: Fordeler arbejdsbyrden på tværs af flere CPU-kerner effektivt.

Her er et eksempel på en nøglefunktion, der implementerer kvantisering og inferens i BitNet:

 
def bitlinear_forward(input, weight, scale):
    # Quantize the input using absmax quantization
    input_q = quantize(input)
    
    # Perform binary matrix multiplication
    output = binary_matmul(input_q, weight)
    
    # Scale the output to match the original precision
    return output * scale

def quantize(x):
    # Perform absmax quantization
    scale = torch.max(torch.abs(x))
    return torch.clamp(x / scale, -1, 1) * scale

# Binarization function for 1-bit weights
def binarize_weights(W):
    alpha = W.mean()
    W_binarized = np.sign(W - alpha)
    return W_binarized