Platforma wnioskowania firmy Microsoft wprowadza 1-bitowe duże modele językowe do urządzeń lokalnych

W październiku 17, 2024, Microsoft ogłosił BitNet.cpp, framework wnioskowania zaprojektowany do uruchamiania 1-bitowych skwantowanych modeli LLM (Large Language Models). BitNet.cpp to znaczący postęp w Gen AI, umożliwiający wydajne wdrażanie 1-bitowych LLM na standardowych procesorach, bez konieczności stosowania drogich procesorów graficznych. Rozwój ten demokratyzuje dostęp do LLM, udostępniając je na szerokiej gamie urządzeń i dając nowe możliwości w aplikacjach AI na urządzeniach.

Zrozumienie 1-bitowych modeli dużego języka

Modele dużego języka (LLM) tradycyjnie wymagały znacznych zasobów obliczeniowych ze względu na używanie przez nie precyzyjnych liczb zmiennoprzecinkowych (zwykle FP16 lub BF16) do określania wag modeli. Ta konieczność sprawiła, że ​​wdrażanie LLM stało się kosztowne i energochłonne.

W swojej istocie 1-bitowe LLM-y wykorzystują ekstremalne techniki kwantyzacji do reprezentowania wag modeli przy użyciu tylko trzech możliwych wartości: -1, 0 i 1, stąd określenie „1.58 bit” (ponieważ do zakodowania trzech stanów potrzeba nieco więcej niż jednego bitu).

Trójskładnikowy system wagowy

Koncepcja

Kwantyzacja 1-bitowa w BitNet.cpp jest trójkowym systemem wag. BitNet działa tylko z trzema możliwymi wartościami dla każdego parametru:

• -1 (negatywny)
• 0 (neutralny)
• 1 (pozytywny)

W rezultacie wymagane jest przechowywanie około 1.58 bitów na parametr, stąd nazwa BitNet b1.58Ta drastyczna redukcja szerokości bitowej parametru prowadzi do imponującej redukcji wykorzystania pamięci i złożoności obliczeniowej, ponieważ większość mnożeń zmiennoprzecinkowych jest zastępowana prostymi dodawaniami i odejmowaniami.

Podstawa Matematyczna

Kwantyzacja 1-bitowa polega na przekształceniu wag i aktywacji do ich reprezentacji trójkowej poprzez następujące kroki:

1. Binaryzacja wagi

Binaryzacja wag polega na ich centralizacji wokół średniej (α), co skutkuje reprezentacją trójkową. Transformacja jest wyrażona matematycznie jako:

Wfâ € <=Znak(W-α)

Gdzie:

• W jest oryginalną macierzą wagową.
• α jest średnią wagową.
• Znak(x) powraca +1 if x > 0 oraz -1 Inaczej.

2. Kwantowanie aktywacji

Kwantowanie aktywacji zapewnia, że ​​dane wejściowe są ograniczone do określonej szerokości bitowej:

x^eâ € <=Ilościowo(x)=Spinacze(γx×Qbâ € <â € <,-Qbâ € <+ϵ,Qbâ € <-ϵ)

Gdzie:

• Qb = 2(b−1)2^{(b-1)}2(b-1) jest maksymalnym poziomem kwantyzacji dla b-szerokość bitowa.
• γ jest maksymalną wartością bezwzględną x (oznaczone jako ∣∣x∣∣∞â € <).
• ε jest małą liczbą zapobiegającą przepełnieniu podczas obliczeń.

3. Operacja BitLiniowa

Warstwa BitLinear zastępuje tradycyjne mnożenie macierzy uproszczoną operacją:

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

Gdzie:

• β jest współczynnikiem skalowania stosowanym w celu minimalizacji błędów aproksymacji.
• γ skaluje aktywacje.
• P_b jest współczynnikiem kwantyzacji.

Taka transformacja umożliwia efektywne obliczenia przy jednoczesnym zachowaniu wydajności modelu.

Implikacje dotyczące wydajności

Wydajność pamięci

Trójskładnikowy system wagowy znacznie redukuje wymagania dotyczące pamięci:

• Tradycyjne studia LLM: 16 bitów na wagę
• BitNet.cpp: 1.58 bitów na wagę

To zmniejszenie oznacza oszczędność pamięci rzędu 90% w porównaniu do tradycyjnych modeli 16-bitowych, co pozwala na dopasowanie większych modeli do tych samych ograniczeń sprzętowych.

Szybkość wnioskowania, efektywność energetyczna (Apple M2)

Szybkość wnioskowania, efektywność energetyczna (i7-13700H)

1. Prędkość wnioskowania: szybsza na obu procesorach

Prędkość wnioskowania jest reprezentowana jako liczba tokenów przetwarzanych na sekundę. Oto podsumowanie obserwacji:

• Na Apple M2 Ultra: BitNet.cpp osiąga do 5.07x przyspieszenie dla większych modeli (30B) w porównaniu do Llama.cpp, ze szczytową prędkością 593.43 tokenów na sekundę dla modelu 125M, który jest 1.37x przyspieszenie. W przypadku większych modeli, takich jak 3.8B i 7B, BitNet.cpp utrzymuje prędkość ponad 84.77 tokenów na sekundę, co pokazuje jego wydajność w różnych skalach.
• Na procesorze Intel i7-13700H: BitNet.cpp osiąga jeszcze bardziej dramatyczne ulepszenia prędkości. Przy rozmiarze modelu 7B BitNet.cpp zapewnia niesamowite przyspieszenie 5.68x w porównaniu do Llama.cpp. W przypadku mniejszych modeli, takich jak 125M, przetwarza 389.08 tokenów na sekundę, który jest 2.37x szybszy niż Llama.cpp.

2. Efektywność energetyczna: przełom dla urządzeń brzegowych

Dostarczone wykresy obejmują również: porównanie kosztów energii, co pokazuje znaczącą redukcję zużycia energii na przetworzony token:

• Na Apple M2 Ultra: Oszczędności energii BitNet.cpp są znaczne. W przypadku modelu 700M zużywa on 55.4% mniej energii na token w porównaniu do Llama.cpp, spadając z 0.314 do 0.140. Tendencja ta utrzymuje się w przypadku większych modeli, przy czym model 70B wykazuje 70.0% redukcja zużycia energii.
• Na procesorze Intel i7-13700H: BitNet.cpp dostarcza 71.9% oszczędności energii w przypadku modelu 700M, gdzie zużycie spada z 1.367 do 0.384. Chociaż dane dotyczące zużycia energii dla modelu 70B w Llama.cpp są niedostępne, BitNet.cpp pozostaje wydajny, a zużycie energii wynosi 17.33 dla modelu 70B.

3. Przekroczenie progu szybkości czytania przez człowieka

Jednym z najciekawszych spostrzeżeń płynących z tych wykresów jest odniesienie do szybkość czytania człowieka, oznaczone w 5-7 żetonów na sekundę. Ta czerwona linia pokazuje, że obie implementacje, szczególnie BitNet.cpp, mogą wygodnie przewyższyć ludzkie prędkości odczytu nawet w przypadku największych modeli:

• On Apple M2 Ultra, BitNet.cpp przewyższa ludzką prędkość odczytu dla wszystkich rozmiarów modeli, przy czym najniższa prędkość wynosi 8.67 tokenów na sekundę dla modelu 70B.
• On Intela i7-13700Hmodel 100B nadal osiąga 1.70 tokenów na sekundę, niemal dotykając dolnego zakresu szybkości czytania człowieka, podczas gdy wszystkie mniejsze modele przewyższają ten punkt odniesienia.

Rozważania szkoleniowe

Estymator prosty (STE)

Ponieważ kwantyzacja 1-bitowa wprowadza funkcje nieróżniczkowalne, trening wymaga specjalistycznej techniki znanej jako Estymator prosty (STE). W tym podejściu gradienty przepływają niezmienione przez punkty nieróżniczkowalne. Oto uproszczona implementacja w Pythonie:

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

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

Mieszane szkolenie precyzyjne

Aby zachować stabilność podczas treningu, mieszana precyzja jest zatrudniony:

• Ciężary i aktywacje:Kwantowane z dokładnością do 1 bitu.
• Gradienty i stany optymalizatora: Przechowywane z większą precyzją.
• Ukryte ciężary:Utrzymywane z dużą precyzją, aby ułatwić dokładne aktualizacje podczas szkolenia.

Strategia dużego współczynnika uczenia się

Unikalnym wyzwaniem w przypadku modeli 1-bitowych jest to, że małe aktualizacje mogą nie mieć wpływu na binarne wagi. Aby temu zaradzić, zwiększa się szybkość uczenia, co zapewnia szybszą konwergencję i lepszą optymalizację w porównaniu z tradycyjnymi podejściami.

Kwantowanie i normalizacja grup

Wprowadzenie BitNet.cpp Kwantowanie i normalizacja grup aby zwiększyć paralelizm modelu. Zamiast obliczać parametry dla całej macierzy wag, BitNet dzieli wagi i aktywacje na wiele grup (G).â € <

Grupowanie takie pozwala na wydajne przetwarzanie równoległe bez dodatkowej komunikacji między grupami, co pozwala na szkolenie i wnioskowanie w modelach na dużą skalę.

Notatki dotyczące wdrożenia i optymalizacji

Optymalizacja procesora

BitNet.cpp wykorzystuje kilka optymalizacji niskiego poziomu w celu osiągnięcia maksymalnej wydajności procesora:

• Operacje wektorowe:Wykorzystuje instrukcje SIMD do wydajnego wykonywania manipulacji bitowych.
• Dostęp do pamięci przyjazny dla pamięci podręcznej:Strukturyzacja danych w celu zminimalizowania błędów w pamięci podręcznej.
• Przetwarzanie równoległe:Efektywnie rozdziela obciążenie pomiędzy wiele rdzeni procesora.

Oto przykład kluczowej funkcji implementującej kwantyzację i wnioskowanie w 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