Microsofts Inference Framework Brengt 1-Bit Large Language Models naar Lokale Apparaten

Op 17 oktober 2024 kondigde Microsoft BitNet.cpp 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 aanzienlijke rekenbronnen nodig vanwege het 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 Systeem

Het Concept

De 1-bit quantificatie in BitNet.cpp is een ternair weight-systeem. 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 bits 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 Grondslag

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

1. Gewicht Binarisatie

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

Wf=Sign(W−α)

Waar:

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

2. Activatie Quantificatie

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. BitLinear Operatie

De BitLinear-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.

Prestatiegevolgen

Geheugenefficiëntie

Het ternaire weight-systeem reduceert de geheugenvereisten aanzienlijk:

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

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

Inference-snelheid, Energie-efficiëntie (Apple M2)

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

1. Inference-snelheid: Sneller op zowel 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 snelheidswinst van maximaal 5,07x voor grotere modellen (30B) in vergelijking met Llama.cpp, met een pieksnelheid van 593,43 tokens per seconde voor een 125M-model, wat een 1,37x snelheidswinst 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 i7-13700H: BitNet.cpp bereikt nog dramatischere snelheidswinsten. Bij een modelgrootte van 7B levert BitNet.cpp een ongelooflijke 5,68x snelheidswinst op in vergelijking met 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 tonen ook energiekostenvergelijkingen, die een aanzienlijke reductie in energieverbruik per verwerkt token laten zien:

• Op Apple M2 Ultra: BitNet.cpp’s energiewinsten 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, met het 70B-model dat een 70,0% reductie in energieverbruik laat zien.
• Op Intel i7-13700H: BitNet.cpp levert 71,9% energiewinst 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. De Menselijke Leessnelheid overschrijden

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, de menselijke leessnelheid 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 1,70 tokens per seconde, wat net onder de ondergrens van de menselijke leessnelheid ligt, 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 genaamd 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()

@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 Optimizer Statussen: Opgeslagen in hogere precisie.
• Latente Gewichten: Onderhouden in hoge precisie om accurate updates tijdens de training te faciliteren.

Grote Leerstrate Strategie

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 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 wordt.

Implementatiedetails en Optimalisaties

CPU-optimalisatie

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

• Gevectoriseerde Operaties: Maakt gebruik van SIMD-instructies om bitmanipulaties efficiënt uit te voeren.
• Cache-vriendelijke Geheugen_toegang: Structureert gegevens om cache-misses te minimaliseren.
• Parallel Verwerking: Distribueert de workload effectief over meerdere CPU-kernen.

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

def bitlinear_forward(input, weight, scale):
# Quantizeer de invoer met behulp van absmax-quantificatie
input_q = quantize(input)

# Voer binaire matrixvermenigvuldiging uit
output = binary_matmul(input_q, weight)

# Schaal de uitvoer om overeen te komen met de oorspronkelijke precisie
return output * scale

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

# Binarisatiefunctie voor 1-bit gewichten
def binarize_weights(W):
alpha = W.mean()
W_binarized = np.sign(W - alpha)
return W_binarized