Microsofts Inference Framework brengt 1-Bit Large Language Models naar lokale apparaten

Op 17 oktober 2024 kondigde Microsoft BitNet.cpp (MSFT ) aan, een inference-framework ontworpen om 1-bit gequantificeerde Large Language Models (LLM’s) uit te voeren. BitNet.cpp is een significante vooruitgang in Gen AI, waardoor de implementatie van 1-bit LLM’s efficiënt mogelijk is op standaard CPU’s, zonder dat dure GPU’s nodig zijn. Deze ontwikkeling democratiseert de toegang tot LLM’s, waardoor ze beschikbaar zijn op een breed scala aan apparaten en nieuwe mogelijkheden biedt voor on-device AI-toepassingen.

1-Bit Large Language Models begrijpen

Large Language Models (LLM’s) hebben traditioneel significante rekenbronnen nodig vanwege hun gebruik van hoge precisie drijvende komma-getallen (meestal FP16 of BF16) voor modelgewichten. Deze noodzaak heeft het implementeren van LLM’s duur en energievretend gemaakt.

In hun kern gebruiken 1-bit LLM’s extreme quantificatietechnieken om modelgewichten weer te geven met behulp van slechts drie mogelijke waarden: -1, 0 en 1, vandaar de term “1,58-bit” (aangezien het iets meer dan één bit vereist om drie staten te coderen).

Ternary Weight System

Het Concept

De 1-bit quantificatie in BitNet.cpp is een ternair gewichtsysteem. BitNet werkt met slechts drie mogelijke waarden voor elke parameter:

• -1 (negatief)
• 0 (neutraal)
• 1 (positief)

Dit resulteert in een opslagvereiste van ongeveer 1,58 bit per parameter, vandaar de naam BitNet b1.58. Deze drastische reductie in parameterbitbreedte leidt tot een indrukwekkende reductie in geheugengebruik en berekeningscomplexiteit, aangezien de meeste drijvende komma-vermenigvuldigingen worden vervangen door eenvoudige optellingen en aftrekkingen.

Wiskundige basis

1-bit quantificatie omvat het transformeren van gewichten en activaties naar hun ternaire representatie via de volgende stappen:

1. Gewichtsbinarisatie

Het binariseren van de gewichten houdt in dat ze worden gecentreerd rond de mediaan (α), waardoor een ternaire representatie ontstaat. De transformatie wordt wiskundig uitgedrukt als:

Wf​=Sign(W−α)

Waar:

• W is de oorspronkelijke gewichtsmatrix.
• α is de mediaan van de gewichten.
• Sign(x) retourneert +1 als x > 0 en -1 anders.

2. Activatiequantificatie

Het quantificeren van activaties zorgt ervoor dat de invoer wordt beperkt tot een gespecificeerde bitbreedte:

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

Waar:

• Qb = 2(b−1)2^{(b-1)}2(b−1) is de maximale quantificatieniveau voor b-bit breedte.
• γ is de maximale absolute waarde van x (aangeduid als ∣∣x∣∣∞​).
• ε is een kleine waarde om overloop tijdens berekeningen te voorkomen.

3. BitLineaire operatie

De BitLineaire laag vervangt traditionele matrixvermenigvuldigingen door een vereenvoudigde operatie:

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

Waar:

• β is een schaalfactor die wordt gebruikt om benaderingsfouten te minimaliseren.
• γ schaalt de activaties.
• Q_b is de quantificatiefactor.

Deze transformatie maakt efficiënte berekeningen mogelijk terwijl de prestaties van het model behouden blijven.

Prestatie-implicaties

Geheugenefficiëntie

Het ternaire gewichtsysteem reduceert de geheugenvereisten aanzienlijk:

• Traditionele LLM’s: 16 bit per gewicht
• BitNet.cpp: 1,58 bit per gewicht

Deze reductie vertaalt zich in een geheugensbesparing van ongeveer 90% ten opzichte van traditionele 16-bit modellen, waardoor grotere modellen binnen dezelfde hardwarebeperkingen passen.

Inference-snelheid, Energie-efficiëntie (Apple [securities_stock_price_tag symbol="AAPL" exchange="NASDAQ"] M2)

Inference-snelheid, Energie-efficiëntie (i7-13700H)

1. Inference-snelheid: Sneller op beide CPU’s

De inference-snelheid wordt weergegeven als het aantal tokens dat per seconde wordt verwerkt. Hieronder volgt een overzicht van de observaties:

• Op Apple M2 Ultra: BitNet.cpp bereikt een snelheidstoename van maximaal 5,07x voor grotere modellen (30B) in vergelijking met Llama.cpp, met een topsnelheid van 593,43 tokens per seconde voor een 125M-model, wat een 1,37x snelheidstoename is. Voor grotere modellen zoals 3,8B en 7B behoudt BitNet.cpp een snelheid van meer dan 84,77 tokens per seconde, waarmee het zijn efficiëntie over verschillende schalen aantoont.
• Op Intel (INTC ) i7-13700H: BitNet.cpp bereikt nog dramatischere snelheidsverbeteringen. Bij een modelgrootte van 7B levert BitNet.cpp een 5,68x snelheidstoename ten opzichte van Llama.cpp. Voor kleinere modellen zoals 125M verwerkt het 389,08 tokens per seconde, wat 2,37x sneller is dan Llama.cpp.

2. Energie-efficiëntie: Een game-changer voor edge-apparaten

De grafieken bevatten ook energiekostenvergelijkingen, die een aanzienlijke reductie in energieverbruik per verwerkt token laten zien:

• Op Apple M2 Ultra: De energibesparingen van BitNet.cpp zijn aanzienlijk. Voor het 700M-model verbruikt het 55,4% minder energie per token in vergelijking met Llama.cpp, dalend van 0,314 naar 0,140. Deze trend zet zich voort voor grotere modellen, waarbij het 70B-model een 70,0% reductie in energieverbruik laat zien.
• Op Intel i7-13700H: BitNet.cpp levert 71,9% energibesparingen voor het 700M-model, met een verbruik dat daalt van 1,367 naar 0,384. Hoewel energiedata voor het 70B-model in Llama.cpp niet beschikbaar is, blijft BitNet.cpp efficiënt, met een energieverbruik van 17,33 voor het 70B-model.

3. Het overschrijden van de menselijke leessnelheidsbenchmark

Een van de meest interessante inzichten uit deze grafieken is de verwijzing naar menselijke leessnelheid, gemarkeerd bij 5-7 tokens per seconde. Deze rode lijn toont aan dat beide implementaties, vooral BitNet.cpp, menselijke leessnelheden comfortabel kunnen overschrijden, zelfs voor de grootste modellen:

• Op Apple M2 Ultra overschrijdt BitNet.cpp de menselijke leessnelheid voor alle modelgroottes, met de laagste snelheid van 8,67 tokens per seconde voor een 70B-model.
• Op Intel i7-13700H bereikt het 100B-model nog steeds 1,70 tokens per seconde, wat bijna de onderste grens van de menselijke leessnelheid bereikt, terwijl alle kleinere modellen deze benchmark overschrijden.

Trainingsoverwegingen

Straight-Through Estimator (STE)

Aangezien 1-bit quantificatie niet-differentieerbare functies introduceert, omvat de training een gespecialiseerde techniek bekend als de Straight-Through Estimator (STE). In deze aanpak stromen de gradiënten ongewijzigd door niet-differentieerbare punten. Hieronder volgt een vereenvoudigde implementatie in Python:

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

<p>@staticmethod
def backward(ctx, grad_output):
return grad_output

Gemengde precisietraining

Om de stabiliteit tijdens de training te behouden, wordt gemengde precisie gebruikt:

• Gewichten en activaties: Gequantificeerd naar 1-bit precisie.
• Gradiënten en optimizerstaten: Opgeslagen in hogere precisie.
• Latente gewichten: Onderhouden in hoge precisie om accurate updates tijdens de training mogelijk te maken.

Grote leerstrate

Een unieke uitdaging met 1-bit modellen is dat kleine updates de gebinariseerde gewichten mogelijk niet beïnvloeden. Om dit te mitigeren, wordt de leerstrate verhoogd, waardoor snellere convergentie en betere optimalisatie mogelijk zijn in vergelijking met traditionele benaderingen.

Groepsquantificatie en normalisatie

BitNet.cpp introduceert groepsquantificatie en normalisatie om modelparallelisme te verbeteren. In plaats van parameters voor de hele gewichtsmatrix te berekenen, deelt BitNet de gewichten en activaties op in meerdere groepen (G).
Dit groeperen maakt efficiënte parallelverwerking mogelijk zonder extra communicatie tussen groepen, waardoor grote modeltraining en inferentie mogelijk worden.

Implementatienotities en optimalisaties

CPU-optimalisatie

BitNet.cpp maakt gebruik van verschillende lage-niveau-optimalisaties om de maximale CPU-prestaties te bereiken:

• Vectorized operaties: Maakt gebruik van SIMD-instructies om bitmanipulaties efficiënt uit te voeren.
• Cache-vriendelijke geheugen-toegang: Structureert gegevens om cache-misses te minimaliseren.
• Parallelle verwerking: Verdeelt de workload efficiënt over meerdere CPU-kernen.

Hieronder volgt een voorbeeld van een sleutelfunctie die quantificatie en inferentie in BitNet implementeert:

<p># Binarisatie van 1-bit gewichten
def binarize_weights(W):
alpha = W.mean()
W_binarized = np.sign(W - alpha)
return W_binarized</p>