Connect with us

Microsofts Inferensramme bringer 1-bits store språkmodeller til lokale enheter

Kunstig intelligens

Microsofts Inferensramme bringer 1-bits store språkmodeller til lokale enheter

mm
Published
Updated
Understanding 1-bit LLMs and Microsoft's BitNet.cpp Framework

Den 17. oktober 2024 annonserte Microsoft BitNet.cpp, en inferensramme designet for å kjøre 1-bits kvantiserte store språkmodeller (LLM). BitNet.cpp er et betydelig fremsteg i Gen AI, som muliggjør effektiv deployering av 1-bits LLM på standard-CPUer uten å kreve dyre GPUer. Denne utviklingen demokratiserer tilgangen til LLM, gjør dem tilgjengelige på en rekke enheter og åpner opp for nye muligheter i on-device AI-applikasjoner.

Forstå 1-bits store språkmodeller

Store språkmodeller (LLM) har tradisjonelt sett krevd betydelige beregningsressurser på grunn av deres bruk av høy-presisjons flyttall (vanligvis FP16 eller BF16) for modellvekt. Denne nødvendigheten har gjort det dyrt og energikrevende å deployere LLM.

I kjernen bruker 1-bits LLM ekstreme kvantiseringsteknikker for å representere modellvekt med kun tre mulige verdier: -1, 0 og 1, derav betegnelsen “1,58-bits” (da det krever litt mer enn en bit for å kode tre tilstander).

Ternær vektsystem

Konseptet

1-bits kvantisering i BitNet.cpp er et ternært vektsystem. BitNet opererer med kun tre mulige verdier for hver parameter:

  • -1 (negativ)
  • 0 (nøytral)
  • 1 (positiv)

Dette resulterer i en lagringskrav på omtrent 1,58 biter per parameter, derav navnet BitNet b1,58. Denne drastiske reduksjonen i parameterbitbredde fører til en imponerende reduksjon i minnebruk og beregningskompleksitet, da de fleste flyttalls-multiplikasjoner erstattes med enkle addisjoner og subtraksjoner.

Matematisk grunnlag

1-bits kvantisering innebærer å transformere vekter og aktiveringer til deres ternære representasjon gjennom følgende steg:

1. Vektbinarisering

Binarisering av vekter innebærer å sentrere dem rundt gjennomsnittet (α), noe som resulterer i en ternær representasjon. Transformasjonen uttrykkes matematisk som:

Wf​=Sign(W−α)

Hvor:

  • W er den opprinnelige vektmatrisen.
  • α er gjennomsnittet av vektene.
  • Sign(x) returnerer +1 hvis x > 0 og -1 ellers.

2. Aktiveringskvantisering

Kvantisering av aktiveringer sikrer at inndata er begrenset til en bestemt bitbredde:

Hvor:

  • Qb = 2(b−1)2^{(b-1)} er den maksimale kvantiseringen for b-bit bredde.
  • γ er den maksimale absoluttverdien av x (betegnet som ∣∣x∣∣∞).
  • ε er et lite tall for å forhindre overflyt under beregninger.

3. BitLineær operasjon

BitLineær laget erstatter tradisjonelle matrisemultiplikasjoner med en forenklet operasjon:

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

Hvor:

  • β er en skaleringsfaktor som brukes for å minimere approksimasjonsfeil.
  • γ skalerer aktiveringer.
  • Q_b er kvantiseringsfaktoren.

Denne transformasjonen muliggjør effektive beregninger samtidig som modellens ytelse bevares.

Ytelsesimplikasjoner

Minneeffektivitet

Det ternære vektsystemet reduserer minnekravene betydelig:

  • Tradisjonelle LLM: 16 biter per vekt
  • BitNet.cpp: 1,58 biter per vekt

Denne reduksjonen oversettes til en minnesparing på omtrent 90% sammenlignet med tradisjonelle 16-bits modeller, noe som gjør det mulig å kjøre større modeller innenfor samme maskinvarebegrensninger.

Energi-effektivitet

Innsiktshastighet, energi-effektivitet (Apple M2)

 

Innsiktshastighet: Raskere på begge CPUer

Innsiktshastighet, energi-effektivitet (i7-13700H)

1. Innsiktshastighet: Raskere på begge CPUer

Innsiktshastighet er representert som antall token prosessert per sekund. Her er en oppsummering av observasjonene:

  • På Apple M2 Ultra: BitNet.cpp oppnår opptil 5,07x hastighetsforbedring for større modeller (30B) sammenlignet med Llama.cpp, med en topphastighet på 593,43 token per sekund for en 125M-modell, noe som er en 1,37x hastighetsforbedring. For større modeller som 3,8B og 7B, opprettholder BitNet.cpp en hastighet over 84,77 token per sekund, noe som viser dens effektivitet over skala.
  • På Intel i7-13700H: BitNet.cpp oppnår enda mer dramatiske hastighetsforbedringer. Ved 7B-modellstørrelse, oppnår BitNet.cpp en usedvanlig 5,68x hastighetsforbedring sammenlignet med Llama.cpp. For mindre modeller som 125M, prosesserer den 389,08 token per sekund, noe som er 2,37x raskere enn Llama.cpp.

2. Energi-effektivitet: En game-changer for edge-enheter

Grafene inkluderer også energi-kost-sammenligninger, som viser en betydelig reduksjon i energiforbruk per token prosessert:

  • På Apple M2 Ultra: BitNet.cpps energibesparelse er betydelig. For 700M-modellen, forbruker den 55,4% mindre energi per token sammenlignet med Llama.cpp, fra 0,314 til 0,140. Denne trenden fortsetter for større modeller, med 70B-modellen som viser en 70,0% reduksjon i energiforbruk.
  • På Intel i7-13700H: BitNet.cpp leverer 71,9% energibesparelse for 700M-modellen, med forbruk som synker fra 1,367 til 0,384. Selv om energidata for 70B-modellen i Llama.cpp ikke er tilgjengelig, forblir BitNet.cpp effektiv, med energiforbruk på 17,33 for 70B-modellen.

3. Krysser menneskeleseshastighets-benchmarket

En av de mest interessante innsiktene fra disse grafene er referansen til menneskeleseshastighet, markert ved 5-7 token per sekund. Denne røde linjen viser at begge implementeringene, spesielt BitNet.cpp, kan lett overstige menneskeleseshastigheter selv for de største modellene:

  • På Apple M2 Ultra, overstiger BitNet.cpp menneskeleseshastighet for alle modellstørrelser, med den laveste hastigheten på 8,67 token per sekund for en 70B-modell.
  • På Intel i7-13700H, oppnår 100B-modellen 1,70 token per sekund, nære den nedre grensen for menneskeleseshastighet, mens alle mindre modeller overstiger denne benchmarken.

Treningsoverveielser

Rett gjennom-estimatoren (STE)

Ettersom 1-bits kvantisering introduserer ikke-differensierbare funksjoner, involverer trening en spesialisert teknikk kjent som Rett gjennom-estimatoren (STE). I denne tilnærmingen, flyter gradientene uendret gjennom ikke-differensierbare punkter. Her er en forenklet implementering i Python:

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

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

Blandet presisjonstrening

For å opprettholde stabilitet under trening, brukes blandet presisjon:

  • Vekter og aktiveringer: Kvantisert til 1-bits presisjon.
  • Gradier og optimiseringsstater: Lagret i høyere presisjon.
  • Latente vekter: Opprettholdes i høy presisjon for å muliggjøre nøyaktige oppdateringer under trening.

Stor læringshastighets-strategi

En unik utfordring med 1-bits modeller er at små oppdateringer kanskje ikke påvirker binariserte vekter. For å motvirke dette, økes læringshastigheten for å sikre raskere konvergens og bedre optimalisering sammenlignet med tradisjonelle tilnærminger.

Gruppekvantisering og normalisering

BitNet.cpp innfører gruppekvantisering og normalisering for å forbedre modellparallellitet. I stedet for å beregne parametre for hele vektmatrisen, deler BitNet vekter og aktiveringer inn i flere grupper (G).​

Denne grupperingen muliggjør effektiv parallellprosessering uten ekstra kommunikasjon mellom grupper, og muliggjør stor modelltrening og inferens.

Implementasjonsnotater og optimaliseringer

CPU-optimalisering

BitNet.cpp utnytter flere lavnivåoptimaliseringer for å oppnå topp-CPU-ytelse:

  • VEktoriserte operasjoner: Utnytter SIMD-instruksjoner for å utføre bitmanipulasjoner effektivt.
  • Cache-vennlig minnehåndtering: Strukturerer data for å minimere cache-miss.
  • Parallellprosessering: Fordeler arbeidsbyrde effektivt over flere CPU-kjerner.

Her er et eksempel på en nøkelfunksjon som implementerer kvantisering og inferens i BitNet:


def bitlineær_forward(input, vekt, skaler):
# Kvantisér inndata ved hjelp av absmax-kvantisering
input_q = kvantisér(input)

# Utfør binær matrisemultiplikasjon
output = binær_matmul(input_q, vekt)

# Skaler output for å matche originalpresisjon
return output * skaler

def kvantisér(x):
# Utfør absmax-kvantisering
skaler = torch.max(torch.abs(x))
return torch.clamp(x / skaler, -1, 1) * skaler
[/code]

Støttede modeller

Den nåværende utgaven av BitNet.cpp støtter følgende 1-bits LLM tilgjengelig på Hugging Face:

  • bitnet_b1_58-large (0,7 milliarder parametre)
  • bitnet_b1_58-3B (3,3 milliarder parametre)
  • Llama3-8B-1.58-100B-tokens (8,0 milliarder parametre)

Disse modellene er offentlig tilgjengelige for å demonstrere rammenes inferensevne. Selv om de ikke er offisielt trent eller utgitt av Microsoft, viser de rammenes fleksibilitet.

Installasjonsveiledning

For å komme i gang med BitNet.cpp, følg disse trinnene:

Forutsetninger

  1. Python >= 3.9
  2. CMake >= 3.22
  3. Clang >= 18
  4. Conda (høyt anbefalt)

For Windows-brukere, skal Visual Studio installeres med følgende komponenter aktivert:

  • Skrivebordsutvikling med C++
  • C++-CMake-verktøy for Windows
  • Git for Windows
  • C++-Clang-kompilator for Windows
  • MS-Build-støtte for LLVM-verktøysett (Clang)

For Debian/Ubuntu-brukere, er det tilgjengelig et automatisk installasjonsskript:

bash -c "$(wget -O - https://apt.llvm.org/llvm.sh)"

Trinnvis installasjon

  1. Klon repository:
    git clone --recursive https://github.com/microsoft/BitNet.git

    cd BitNet
  2. Install avhengigheter:
    # Opprett en ny Conda-miljø (anbefalt)
    conda create -n bitnet-cpp python=3.9
    conda activate bitnet-cpp

    pip install -r requirements.txt
  3. Bygg og forbered prosjekt: Du kan laste ned en modell direkte fra Hugging Face og konvertere den til en kvantisert format:
    python setup_env.py --hf-repo HF1BitLLM/Llama3-8B-1.58-100B-tokens -q i2_s

    Alternativt, last ned og konverter modellen manuelt:

    huggingface-cli download HF1BitLLM/Llama3-8B-1.58-100B-tokens --local-dir models/Llama3-8B-1.58-100B-tokens

    python setup_env.py -md models/Llama3-8B-1.58-100B-tokens -q i2_s

Kjøre inferens med BitNet.cpp

For å kjøre inferens ved hjelp av rammen, bruk følgende kommando:

python run_inference.py -m models/Llama3-8B-1.58-100B-tokens/ggml-model-i2_s.gguf -p "Sandra reiste til kjøkkenet. Hvor er Sandra?" -n 6 -temp 0.7

Forklaring:

  • -m spesifiserer modellfilstien.
  • -p definerer prompt-teksten.
  • -n setter antall token som skal forutsies.
  • -temp justerer sampling-tilfeldighet (temperatur) under inferens.

Eksempel på utdata

Sandra reiste til kjøkkenet. Hvor er Sandra?

Svar: Sandra er i kjøkkenet.

Tekniske detaljer om BitNet.cpp

BitLineær-lag

BitNet.cpp implementerer en modifisert Transformer-arkitektur, hvor standard matrisemultiplikasjoner erstattes med BitLineær-operasjoner. Denne tilnærmingen sentrerer vekter rundt null før kvantisering og skalerer dem for å redusere approksimasjonsfeil. Den nøkkeltransformasjonsfunksjonen ser slik ut:


# Binarisering av 1-bits vekter
def binarisér_vekter(W):
alpha = W.mean()
W_binarisert = np.sign(W - alpha)
return W_binarisert

Kombinasjonen av sentrerte vekter og skaleringsfaktorer sikrer at kvantisfeilene forblir minimale, og modellens ytelse bevares.

Bransjeimpakt

BitNet.cpp kan ha langtrekkende implikasjoner for deployering av LLM:

  • Tilgjengelighet: Muliggjør at LLM kjøres på standardenheter, demokratiserer tilgangen til kraftig AI.
  • Kostnadseffektivitet: Reduserer behovet for dyre GPUer, senker barrieren for adopsjon.
  • Energi-effektivitet: Sparer energi ved å utnytte standard-CPU-basert inferens.
  • Innovasjon: Åpner opp for nye muligheter for on-device AI, som sanntids språkoversettelse, taleassistenter og privatlivsorienterte applikasjoner uten avhengighet av skytjenester.

Utlendings- og fremtidige retninger

Selv om 1-bits LLM har potensiale, gjenstår flere utfordringer. Disse inkluderer utvikling av robuste 1-bits modeller for ulike oppgaver, optimalisering av maskinvare for 1-bits beregning og oppmuntre utviklere til å adoptere dette nye paradigmet. I tillegg representerer utforskning av 1-bits kvantisering for datavisning eller lydoppgaver en spennende fremtidig retning.

Konklusjon

Microsofts lansering av BitNet.cpp er et betydelig fremsteg. Ved å muliggjøre effektiv 1-bits inferens på standard-CPUer, skaper BitNet.cpp tilgjengelighet og bærekraft av AI. Denne rammen setter scenen for mer portable og kostnadseffektive LLM, og åpner opp for hva som er mulig med on-device AI.

mm

Jeg har brukt de siste fem årene til å dykke ned i den fasiniserende verden av Machine Learning og Deep Learning. Min lidenskap og ekspertise har ført meg til å bidra til over 50 forskjellige prosjekter innen programvareutvikling, med særlig fokus på AI/ML. Min pågående nysgjerrighet har også trukket meg mot Natural Language Processing, et felt jeg er ivrig etter å utforske videre.