Microsoftin päättelykehys tuo 1-bittisiä suuria kielimalleja paikallisiin laitteisiin

Lokakuussa 17, 2024, Microsoft julkisti BitNet.cpp:n, päättelykehys, joka on suunniteltu suorittamaan 1-bittisiä kvantisoituja suuria kielimalleja (LLM). BitNet.cpp on merkittävä edistysaskel Gen AI:ssä, mikä mahdollistaa 1-bittisten LLM:ien tehokkaan käyttöönoton tavallisissa prosessoreissa ilman kalliita grafiikkasuorittimia. Tämä kehitys demokratisoi pääsyn LLM:ihin, mikä tekee niistä saataville monenlaisille laitteille ja tarjoaa uusia mahdollisuuksia laitteiden tekoälysovelluksiin.

1-bittisten suurten kielimallien ymmärtäminen

Suuret kielimallit (LLM) ovat perinteisesti vaatineet merkittäviä laskentaresursseja, koska ne käyttävät erittäin tarkkoja liukulukuja (yleensä FP16 tai BF16) mallipainoissa. Tämä tarve on tehnyt LLM:ien käyttöönotosta kallista ja energiaintensiivistä.

1-bittiset LLM:t käyttävät ytimessä äärimmäisiä kvantisointitekniikoita mallipainojen esittämiseen käyttämällä vain kolmea mahdollista arvoa: -1, 0 ja 1, mistä johtuu termi "1.58-bittinen" (koska se vaatii hieman enemmän kuin yhden bitin koodatakseen kolme osavaltiot).

Kolmiosainen painojärjestelmä

Käsite

BitNet.cpp:n 1-bittinen kvantisointi on kolmiosainen painojärjestelmä. BitNet toimii vain kolmella mahdollisella arvolla kullekin parametrille:

• -1 (negatiivinen)
• 0 (neutraali)
• 1 (positiivinen)

Tämä johtaa noin 1.58 bitin tallennustarpeeseen parametria kohden, mistä johtuu nimi BitNet b1.58. Tämä jyrkkä parametrien bittileveyden pieneneminen johtaa vaikuttavaan muistin käytön vähenemiseen ja laskennan monimutkaisuuteen, koska useimmat liukulukukertoja korvataan yksinkertaisilla yhteen- ja vähennyslaskuilla.

Matemaattinen säätiö

1-bittinen kvantisointi sisältää painojen ja aktivointien muuntamisen kolmiarvoiseksi esitykseksi seuraavien vaiheiden avulla:

1. Painon binarisointi

Painojen binaarisointi edellyttää niiden keskittämistä keskiarvon ympärille (α), jolloin tuloksena on kolmiosainen esitys. Muunnos ilmaistaan ​​matemaattisesti seuraavasti:

Wf----=Merkki(W-α)

Missä:

• W on alkuperäinen painomatriisi.
• α on painojen keskiarvo.
• Merkki (x) Tuotto +1 if x > 0 ja -1 muuten.

2. Aktivoinnin kvantisointi

Aktivointien kvantisointi varmistaa, että tulot on rajoitettu tiettyyn bittileveyteen:

x^e----=kuten(x)=Leikata(γx×Qb--------,-Qb----+ϵ,Qb-----ϵ)

Missä:

• Qb = 2(b-1)2^{(b-1)}2(b-1) on suurin kvantisointitaso b-bitin leveys.
• γ on suurin absoluuttinen arvo x (merkitty nimellä ∣∣x∣∣∞----).
• ε on pieni luku estämään ylivuoto laskelmien aikana.

3. BitLineaarinen toiminta

BitLinear-kerros korvaa perinteiset matriisikertoukset yksinkertaistetulla toiminnolla:

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

Missä:

• β on skaalauskerroin, jota käytetään minimoimaan approksimaatiovirheet.
• γ skaalaa aktivoinnit.
• Q_b on kvantisointitekijä.

Tämä muunnos mahdollistaa tehokkaat laskennat säilyttäen samalla mallin suorituskyvyn.

Suorituskyvyn vaikutukset

Muistin tehokkuus

Kolmiosainen painojärjestelmä vähentää merkittävästi muistivaatimuksia:

• Perinteiset LLM:t: 16 bittiä painoa kohti
• BitNet.cpp: 1.58 bittiä painoa kohti

Tämä vähennys merkitsee noin muistin säästöä 90% verrattuna perinteisiin 16-bittisiin malleihin, mikä mahdollistaa suuremmat mallit mahtumaan samoihin laitteistorajoituksiin.

Päätelmänopeus, energiatehokkuus (Apple M2)

Päätelmänopeus, energiatehokkuus (i7-13700H)

1. Päätelmänopeus: Nopeampi molemmissa prosessoreissa

Päätelmän nopeus esitetään sekunnissa käsiteltyjen tokenien lukumääränä. Tässä on havaintojen erittely:

• Apple M2 Ultrassa: BitNet.cpp saavuttaa jopa 5.07x nopeutta suurempiin malleihin (30B) verrattuna Llama.cpp:hen, huippunopeudella 593.43 merkkiä sekunnissa 125M mallille, joka on a 1.37x vauhtia. Suuremmissa malleissa, kuten 3.8B ja 7B, BitNet.cpp ylläpitää yli 84.77 merkkiä sekunnissa nopeutta, mikä osoittaa sen tehokkuuden eri mittakaavassa.
• Intel i7-13700H:ssa: BitNet.cpp saavuttaa vieläkin dramaattisia nopeusparannuksia. 7B-mallissa BitNet.cpp tarjoaa uskomaton 5.68-kertainen nopeus verrattuna Llama.cpp:hen. Pienemmille malleille, kuten 125M, se käsittelee 389.08 merkkiä sekunnissa, Joka on 2.37x nopeampi kuin Llama.cpp.

2. Energiatehokkuus: Edge-laitteiden pelinvaihtaja

Toimitetut kaaviot sisältävät myös energiakustannusten vertailut, mikä osoittaa merkittävän energiankulutuksen alenemisen prosessoitua merkkiä kohden:

• Apple M2 Ultrassa: BitNet.cpp:n energiansäästö on huomattava. 700M-mallissa se kuluttaa 55.4% vähemmän energiaa per merkki verrattuna Llama.cpp:hen, putoaa 0.314 ja 0.140. Tämä suuntaus jatkuu suuremmissa malleissa, 70B-mallissa a 70.0 % vähennys energiankulutuksessa.
• Intel i7-13700H:ssa: BitNet.cpp toimittaa 71.9% energiansäästö 700M-mallille, jonka kulutus laskee 1.367 että 0.384. Vaikka Llama.cpp:n 70B-mallin energiatietoja ei ole saatavilla, BitNet.cpp on edelleen tehokas energiankulutuksen ollessa n. 17.33 70B mallille.

3. Ihmisen lukunopeuden vertailuarvon ylittäminen

Yksi mielenkiintoisimmista oivalluksista näistä kaavioista on viittaus ihmisen lukunopeus, merkitty osoitteeseen 5-7 merkkiä sekunnissa. Tämä punainen viiva osoittaa, että molemmat toteutukset, erityisesti BitNet.cpp, voivat mukavasti ylittää ihmisen lukunopeudet jopa suurimmissa malleissa:

• On Apple M2 Ultra, BitNet.cpp ylittää ihmisen lukunopeuden kaikissa mallikooissa, pienin nopeus on 8.67 merkkiä sekunnissa 70B mallille.
• On Intel i7-13700H, 100B-malli saavuttaa edelleen 1.70 merkkiä sekunnissa, koskettaa melkein ihmisen lukunopeuden alempaa aluetta, kun taas kaikki pienemmät mallit ylittävät tämän vertailuarvon.

Harjoittelun näkökohdat

Straight-through Estimator (STE)

Koska 1-bittinen kvantisointi tuo ei-differoioituvia toimintoja, koulutus sisältää erikoistekniikan, joka tunnetaan nimellä Straight-through Estimator (STE). Tässä lähestymistavassa gradientit virtaavat muuttumattomina ei-differentoivien pisteiden läpi. Tässä on yksinkertaistettu toteutus Pythonissa:

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

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

Mixed Precision Training

Vakauden ylläpitämiseksi harjoituksen aikana, sekoitettu tarkkuus on työssä:

• Painot ja aktivoinnit: Kvantisoitu 1 bitin tarkkuudella.
• Gradientit ja optimoijan tilat: Säilytetty suuremmalla tarkkuudella.
• Piilevät painot: Ylläpidetty korkealla tarkkuudella tarkkojen päivitysten helpottamiseksi harjoittelun aikana.

Suuri oppimisaste -strategia

Ainutlaatuinen haaste 1-bittisille malleille on, että pienet päivitykset eivät ehkä vaikuta binaarisoituihin painoihin. Tämän lieventämiseksi oppimisnopeutta nostetaan, mikä varmistaa nopeamman konvergenssin ja paremman optimoinnin perinteisiin lähestymistapoihin verrattuna.

Ryhmäkvantisointi ja normalisointi

BitNet.cpp esittelee Ryhmäkvantisointi ja normalisointi parantaa mallin rinnakkaisuutta. Sen sijaan, että BitNet laskeisi parametreja koko painomatriisille, se jakaa painot ja aktivoinnit useisiin ryhmiin (G).----

Tämä ryhmittely mahdollistaa tehokkaan rinnakkaiskäsittelyn ilman ylimääräistä ryhmien välistä viestintää, mikä mahdollistaa laajamittaisen mallikoulutuksen ja päättelyn.

Käyttöönoton huomautukset ja optimoinnit

Prosessorin optimointi

BitNet.cpp hyödyntää useita matalan tason optimointeja saavuttaakseen huippusuorittimen suorituskyvyn:

• Vektorisoidut toiminnot: Käyttää SIMD-käskyjä suorittaakseen bittikäsittelyt tehokkaasti.
• Välimuistiystävällinen käyttö: strukturoi tiedot minimoimaan välimuistin puuttumisen.
• Rinnakkaiskäsittely: Jakaa työkuorman tehokkaasti useiden suorittimen ytimien kesken.

Tässä on esimerkki avainfunktiosta, joka toteuttaa kvantisoinnin ja päättelyn BitNetissä:

 
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