wszystkie wpisy 2026 BitNet
BitNet · 2026-11-06 · 18 min

BitNet od zera – Po co sieć z wagami −1, 0, +1?

Dwadzieścia siedem miliardów parametrów na karcie z sześcioma gigabajtami pamięci. Nie w 2028 roku i nie „w teorii”, tylko plik do pobrania dziś. Od tego zaczynam tę serię: jak to w ogóle jest możliwe i czy da się to zbudować samemu, od pustego katalogu.

Ternary Bonsai 2 27B (PrismML) to Qwen3.8-27B skompresowany do 5,95 GB przy 98,2% jakości oryginału w FP16, z wagami ternarnymi łącznie z embeddingiem i głową (źródło: karta modelu na Hugging Face; liczby autorskie, niezweryfikowane niezależnie). To nie obietnica z publikacji z 2024 roku, tylko plik, który możesz pobrać, zanim skończysz czytać to zdanie.

Objaśnienie. Model językowy to wielka tablica liczb i zwykle każda z nich zajmuje 2 albo 4 bajty. Okazuje się, że można zbudować sieć, w której każda liczba ma tylko trzy możliwe wartości: −1, 0 i +1. Taka sieć dalej działa, a komputer nie musi mnożyć (mnożenie przez −1, 0 lub +1 to odjęcie, pominięcie albo dodanie). Żeby dopisać jedno słowo, komputer musi przeczytać wszystkie te liczby. Pamięć ma ograniczoną przepustowość, tak jak rura ma ograniczony przepływ, więc im mniej bajtów zajmuje model, tym szybciej odpowiada. BitNet zmniejsza wagę warstwy z 2 bajtów do 2 bitów, czyli osiem razy (a względem 4 bajtów kilkanaście razy). Ale część modelu, czyli słownik, zostaje w starym formacie, więc cały plik prawdziwego modelu jest mniejszy mniej więcej czterokrotnie. W tym odcinku liczę, ile to daje w megabajtach i w słowach na sekundę i gdzie ten rachunek przestaje się zgadzać. Cała seria buduje taką sieć od zera i pokazuje każdy krok.

Strona z testem: Kalkulator rozmiaru: ile miejsca zajmuje model i jak szybko może odpowiadać

1. Sieć to tablice liczb

Model językowy w trakcie generowania robi w kółko to samo: bierze wektor liczb opisujący „stan” i mnoży go przez macierz wag. Parametrów jest tyle, ile komórek w tych macierzach. Model „2 miliardy parametrów” to dosłownie dwa miliardy liczb.

Ile miejsca zajmuje jedna liczba, zależy od formatu:

format bity 1 mld wag uwaga
fp32 32 4,00 GB klasyczny trening
bf16 / fp16 16 2,00 GB standard inferencji
int8 8 1,00 GB kwantyzacja potreningowa
4-bit (Q4_K_M ≈ 4,85) 4,85 606 MB typowy GGUF na laptopa; czyste Q4_0 / Q4_K_S to 4,5 (Q4_K_M zapisuje połowę attn.v/ffn.down i output w Q6_K – PR #1684)
ternarny zapisany na 2 bitach 2 250 MB BitNet
ternarny teoretycznie log₂ 3 = 1,585 198 MB granica informacyjna

Ostatni wiersz wymaga komentarza. Waga o trzech możliwych wartościach niesie log₂ 3 = 1,585 bita informacji (gdy wszystkie trzy stany są jednakowo prawdopodobne) i stąd „b1.58” w nazwie BitNet b1.58. Nikt jednak nie zapisuje jej na 1,585 bita, bo odczyt takiego zapisu byłby strasznie uciążliwy. Zapisuję ją na dwóch bitach, cztery wagi w bajcie. Wychodzi 26% narzutu względem granicy (2 / 1,585 = 1,26; w przeliczeniu na 2-bitowe słowo marnuje się 21% bitów – obie liczby opisują to samo, w serii używam 26%). W zamian dekodowanie sprowadza się do przesunięcia bitowego. Krótko: płacę za prostotę. Czwarty, nadmiarowy kod da się przy okazji wykorzystać – w odcinku 07 robię z niego znacznik uszkodzonych danych.

2. Maksymalna prędkość: przepustowość pamięci podzielona przez rozmiar modelu

Gdy model generuje token po tokenie (jedna sekwencja naraz, bez łączenia zapytań w batch), każdą wagę czyta raz na token. Górna granica prędkości wynosi więc:

tok/s ≤ przepustowość pamięci [B/s] / rozmiar modelu [B]

Wąskim gardłem nie jest liczba operacji, tylko przepustowość pamięci. Generowanie tekstu to w praktyce czytanie wag z pamięci. Model 8× mniejszy da się przeczytać 8× szybciej. Warstwy ternarne czyta się osiem razy szybciej niż w bf16, ale cały model 2B4T, z embeddingiem w F16, już tylko cztery razy (§3). W reszcie odcinka sprawdzam, czy ta teza (prędkość generowania wyznacza liczba bajtów do przeczytania) broni się w liczbach.

Przepustowość pamięci maszyn, które porównuję:

maszyna przepustowość pamięci pamięć
MacBook Pro M4 Pro 273 GB/s 48 GB
NVIDIA DGX Spark 273 GB/s 128 GB
RTX 4090 1008 GB/s 24 GB
A100 80 GB SXM (chmura; wersja PCIe: 1935 GB/s) 2039 GB/s 80 GB

Uwaga na pułapkę, w którą łatwo wpaść przy czytaniu Wikipedii: dla RTX 4090 krąży liczba 1142 GB/s. Specyfikacja NVIDII podaje 1008 GB/s i tej wartości używam.

Druga obserwacja, mniej oczywista: DGX Spark ma dokładnie taką samą przepustowość pamięci jak M4 Pro (273 GB/s). Spark wygrywa pojemnością pamięci (128 GB wobec 48 GB) i mocą obliczeniową przy treningu. Ale przy samym generowaniu token po tokenie jego maksymalna prędkość jest taka sama. To jedna z tych liczb, które zmieniają decyzję o zakupie.

Drugi zysk: znikają mnożenia. Mnożenie aktywacji przez wagę ze zbioru {−1, 0, +1} to po prostu −x, albo +x. Cała warstwa liniowa to dodawanie i odejmowanie liczb całkowitych.

3. Przykład, który warto zapamiętać: BitNet b1.58 2B4T

Oficjalny model Microsoftu w formacie GGUF (zmierzone na pliku modelu):

  • 30 warstw, d_model 2560, uwaga GQA 20 głów Q / 5 głów KV,
  • 210 tensorów typu I2_S (ternarnych), razem 2 084 044 800 wag → 521 MB,
  • token_embd w F16, głowa współdzieli wagi z embeddingiem (tied): ≈ 328 mln wag → 657 MB,
  • razem wagi ≈ 1,18 GB; sam plik GGUF to 1 187 801 280 B ≈ 1,19 GB (metadane i wyrównanie).

Ten sam rachunek jako tabela, z nagłówka prawdziwego pliku:

składnik ile rozmiar
warstwy ternarne (210 tensorów I2_S) 2 084 044 800 wag × 2 bity 521 MB
embedding F16 (2560 × 128 256) 328 335 360 wag × 2 B 657 MB
normalizacje F32 121 tensorów ~1 MB
razem (wagi + normalizacje) 1,18 GB
to samo w bf16 2,41 mld × 2 B ~4,8 GB

(Tabela sumuje wagi i normalizacje, czyli 1,18 GB. Sam plik GGUF z metadanymi i wyrównaniem ma 1 187 801 280 B ≈ 1,19 GB.)

Zysk jest prawdziwy, 4×, ale nie 8×, bo embedding został w wysokiej precyzji. To pierwsza rzecz, którą w tej serii obiecuję robić inaczej niż marketing: podawać rozmiary razem z embeddingiem.

I tu wchodzi skrót myślowy, który krąży po internecie: „BitNet 2B mieści się w 0,5 GB” albo, w najczęstszej wersji tego kłamstwa, „model 2B schudł z 4 GB do 0,5 GB”. To prawda tylko o warstwach ternarnych. Embedding i głowa zostają w wysokiej precyzji. Powód podany w publikacji BitNet (arXiv:2310.11453 §2): model językowy potrzebuje dokładnych prawdopodobieństw do próbkowania, więc warstwa wyjściowa, a z nią związany embedding, zostaje w wysokiej precyzji. Czy ternaryzacja embeddingu naprawdę „zabija” model, to osobna hipoteza, której w tej serii nie sprawdziłem pomiarem. W §4 pokazuję, że przy kompresji gotowego modelu (Bonsai) da się ją obejść. W efekcie ponad połowa pliku to właśnie embedding. Zajmuje tu więcej miejsca niż wszystkie 2,08 mld wag ternarnych razem.

Maksymalna prędkość dla 1,18 GB:

maszyna maks. prędkość
M4 Pro / DGX Spark ≈ 232 tok/s
RTX 4090 ≈ 856 tok/s
A100 80 GB SXM ≈ 1731 tok/s

(wyliczenie na stronie 01; to górne ograniczenie, nie pomiar – prawdziwy system osiąga jego ułamek)

Dla porównania: Llama-3 8B w bf16 to ~16 GB, czyli najwyżej ≈ 17 tok/s na M4 Pro. Różnica nie bierze się z „lepszej matematyki”, tylko z liczby bajtów, które trzeba przeczytać z pamięci.

4. Dlaczego nie można po prostu zaokrąglić gotowego modelu

Naturalne pytanie: skoro ternarne wagi są takie wygodne, czemu nie wziąć Llamy i nie zaokrąglić jej wag do −1/0/+1?

Bo wyjdzie bełkot. Nie wystarczy tu wczytać model programem wczytującym (loaderem), który nie zna jego architektury – to byłby błąd formatu, a nie dowód, że zaokrąglenie psuje wagi. Mam pomiar na własnych modelach tej serii, a tabela i próbki tekstu są w sekcji „Na stronie” niżej. Zaokrąglenie kasuje prawie całą wiedzę: strata (loss) wraca niemal do poziomu „nic nie wiem”. Mechanizm jest prosty. Model trenowany w wysokiej precyzji rozkłada informację na drobne różnice między wagami, a trzy poziomy je zacierają. Pierwotne źródło dla dużych modeli to seria Spectra/TriLM (niżej).

Ten sam objaw na cudzym modelu opisuje zgłoszenie llama.cpp #15193 (Qwen3-4B → TQ1_0 „outputs messy contents”). To tylko ilustracja – jako dowód lepiej powoływać się na Spectra/TriLM niż na numer zgłoszenia (patrz niżej).

Glina i odlew. Model wytrenowany w wysokiej precyzji jest jak gotowy odlew: każdy szczegół już zastygł w konkretnej, ciągłej wartości. Zaokrąglenie go do trzech poziomów to obtłukiwanie odlewu młotkiem. Trening z kwantyzacją w pętli to lepienie od razu z gliny, która ma tylko trzy grubości. Forma powstaje z uwzględnieniem ograniczenia, a nie wbrew niemu.

BitNet robi to inaczej: trenuje od początku ze świadomością, że wagi będą ternarne (to jest QAT, quantization-aware training). Podczas treningu sieć liczy przebieg w przód na zaokrąglonych wagach i uczy się kompensować zaokrąglenie. W odcinku 05 zobaczysz to na żywo: ten sam model, to samo ziarno losowania, raz z kwantyzacją, raz bez.

Ale uwaga: w 2026 „zaokrąglanie” przestało oznaczać to samo co w 2024

Wszystko powyżej jest prawdą o naiwnym zaokrągleniu i tylko o nim. Równolegle wyrosła druga szkoła, która gotowy model kompresuje, a nie trenuje od zera, i robi to zaskakująco dobrze. Metody z rotacją przestrzeni wag przed kwantyzacją (Bonsai, QuaRot) dochodzą do 98% jakości.

Najczytelniejszy przykład to rodzina Bonsai (PrismML) (źródła: karty modeli na Hugging Face):

Ternary Bonsai 27B Ternary Bonsai 2 27B
model bazowy Qwen3.6-27B Qwen3.8-27B
bity na wagę 2,125 (wdrożeniowo) 1,75 (PTQ1_0)
rozmiar pliku 7,2 GB 5,95 GB
jakość wobec FP16 80,49 wobec 85,07 na 15 testach → 94,6% 84,78 wobec 86,32 na 14 testach → 98,2%
co jest ternarne embeddingi, uwaga, MLP, głowa to samo, „end-to-end”

W tej tabeli zwracam uwagę na dwie rzeczy.

Pierwsza: ternarny jest tam także embedding i głowa. Czyli dokładnie to, co BitNet zostawia w wysokiej precyzji (odcinek 06) i co w §3 tłumaczyło, dlaczego plik 2B4T zajmuje 1,18 GB, a nie 0,52 GB. Bonsai pokazuje, że da się inaczej, kosztem 1,8% jakości. Nie znaczy to, że moja reguła jest błędna. Embedding zostawiam w wysokiej precyzji z wyboru, nie z konieczności: trenuję od zera i nie mam czym nadrobić błędu na wejściu i wyjściu. Oni zaczynają od gotowego, mocnego modelu i tylko go kompresują. To dwie różne sytuacje, a nie dwie odpowiedzi na to samo pytanie.

Druga: 98,2% to nie jest „załamanie jakości”. Ujawniony kawałek metody to blokowa rotacja Hadamarda przed kwantyzacją. Wagi obraca się tak, żeby rozproszyć wartości odstające (outliers), czyli liczby wielokrotnie większe od pozostałych, i dopiero potem zaokrągla. Reszta metody jest zamknięta i nie wiadomo, ile w niej dotrenowania, a liczby pochodzą od autorów, nie z niezależnego pomiaru.

Uczciwa wersja zdania z początku tej sekcji brzmi więc tak: naiwne zaokrąglenie nie działa i nie zadziała; przemyślana kompresja potreningowa działa dziś bardzo dobrze, tylko nie nauczysz się z niej niczego o tym, jak model liczy. Ja idę drogą, która uczy, czyli drogą BitNeta: trening od zera z kwantyzacją w pętli uczenia. Wolniejszą, droższą i jedyną, która pozwala zrozumieć, co się w środku dzieje.

Do tego trzy rzeczy, które trzeba dopowiedzieć:

  • Pierwotny dowód na „od zera bije naiwne PTQ poniżej 4 bitów” istnieje i nie jest numerem zgłoszenia. Seria Spectra / TriLM (arXiv:2407.12327, 2024; Spectra 1.1 arXiv:2506.23025, 2025) trenuje rodziny modeli od 99 mln do 3,9 mld parametrów na 300 mld tokenów w trzech wariantach: FloatLM, QuantLM (PTQ) i TriLM (ternarny od zera). Wychodzi, że TriLM 3,9 B dorównuje FloatLM 3,9 B przy mniejszej liczbie bitów niż FloatLM 830 M. Na to źródło trzeba się powoływać przy zdaniu „naiwne zaokrąglenie nie działa”, a nie na #15193 (źródło; własny pomiar na bitGPT-nano – patrz sekcja „Na stronie”).
  • Rotacja Hadamarda nie jest znakiem rozpoznawczym „drugiej szkoły”. Microsoft używa jej także w treningu od zera: BitNet v2 (arXiv:2504.18415) stosuje transformację Hadamarda tuż przed kwantyzacją aktywacji i od początku trenuje z 4-bitowymi aktywacjami. Rotacja to narzędzie obu szkół.
  • Jest droga trzecia: dostrajanie gotowego modelu metodą QAT. BitNet Distillation (arXiv:2510.13998) to SubLN przed projekcjami wyjściowymi, 10 mld tokenów dalszego pretreningu i destylacja z Qwen3, a na wyjściu model ternarny 10× mniejszy w pamięci. ParetoQ (Meta, arXiv:2502.02631) robi to samo dla 1-4 bitów i sugeruje, że 2 bity bywają praktyczniejsze niż 1,58. Do tej drogi należą też prace z 2026 roku nad Qwen3 (arXiv:2609.01962, 2609.09240) [niezweryfikowane: nieprzeczytane w całości]. Falcon-E (TII, 2025) potwierdza z kolei, że recepturę „od zera” da się powtórzyć poza Microsoftem.

Podział „od zera kontra PTQ” z pierwszego akapitu tej sekcji jest więc uproszczeniem. Dziś to trzy drogi i wspólny zestaw narzędzi.

5. A co z energią?

W publikacji BitNet b1.58 pada liczba 71,4× mniej energii na operacje arytmetyczne. Dobrze wiedzieć, co ona dokładnie znaczy. To oszacowanie energii samych mnożeń i dodawań macierzowych w procesie 7 nm, wyliczone z tabel kosztu operacji, a nie zmierzone zużycie całego systemu. Pamięć, sterowanie, I/O i reszta układu nie znikają, więc w całym systemie zysk jest mniejszy. Traktuj to jako wskazówkę co do rzędu wielkości i kierunku zmiany, a nie jako obietnicę w sprawie rachunku za prąd (źródło: arXiv:2402.17764).

6. Plan serii, zasady i sprzęt

Poza kalkulatorem ten odcinek jest manifestem serii: plan, zasady i rachunek sprzętu. Projekt ma dwa cele: zrozumieć sieć od środka i uruchamiać duże modele na skromnym sprzęcie.

Plan: każdy krok kończy się demem

odcinki co powstaje demo na koniec
03 czytnik cudzych modeli GGUF odczyt nagłówka modelu z 27 mld parametrów
04-05 mikro-autograd + ternarny MLP MNIST 96%+ we własnym frameworku
06-12 rdzeń QAT, tokenizer, bitGPT, kernele, .bitpack ternarny model opowiada bajki, czyta go własny kernel
13-18 kernele GPU (wzorowane na Tritonie i kernelu Microsoftu), współpraca z bitnet.cpp tabela benchmarków, własny model w cudzym silniku
19-20 dyfuzja w pikselach siatki obrazków: FP kontra ternarne
21-22 BitConv2d + bitVAE obraz skompresowany i odtworzony na samych liczbach całkowitych
23 dyfuzja latentna twarze z w 100% własnego toru
24 text-to-image obraz wygenerowany z opisu tekstowego
34, 18 destylacja + serwer lokalny czat z ternarnym modelem 0,6 mld parametrów
25 wideo (cel dodatkowy) klipy + raport badawczy
26-33, 35-37 duży model na małym komputerze: eksperci (MoE), dekodowanie spekulatywne, długi kontekst na razie plan odcinków

Zasady serii, których będę pilnował:

  1. Kod przy każdym odcinku. Strona jest podlinkowana w artykule.
  2. FP-twin zawsze. Każdy model ternarny ma bliźniaka w wysokiej precyzji, trenowanego z tą samą konfiguracją i tym samym ziarnem losowania. Bez niego nie wiadomo, czy słaby wynik to wina kwantyzacji, czy błędu.
  3. Zgodność co do bitu. Każdy nowy kernel musi dać wyniki int32 identyczne co do bitu z implementacją referencyjną. Nie „podobne”.
  4. Wykresy zamiast przymiotników. „Szybciej” nie jest wynikiem, a „1,01 GB/s wobec 0,07 GB/s” jest.

Na stronie

Strona z nagłówka to kalkulator rozmiaru. Pokazuje, ile miejsca zajmuje model i jak szybko może odpowiadać (przepustowość pamięci podzielona przez rozmiar modelu) dla dowolnej precyzji wag.

Pomiar: naiwne zaokrąglenie kontra QAT

model FP wytrenowany ten sam model zaokrąglony po treningu (naiwne PTQ) trenowany z kwantyzacją (QAT, odc. 05/11)
MLP na spirali (odc. 05), 1500 kroków trafność 99,6% 74,2% 99,6%
bitGPT-nano (odc. 11), 400 kroków strata 0,390 na batchach spoza zbioru treningowego 2,785 (losowe zgadywanie = ln 25 = 3,219) 0,459

Próbka z dekodowania zachłannego po naiwnym zaokrągleniu wag bitGPT-nano: maly kot idddd nid niczony dddz nzy klue ny…, a ten sam model trenowany z kwantyzacją wypluwa: maly kot spi na polanie. czy madry kruk spiewa w domu o swicie.

Spróbuj sam

Na stronie tego odcinka (nic nie trzeba instalować):

  1. Ustaw „BitNet b1.58 2B4T” i sprawdź, że wychodzi 521 MB warstw + 657 MB embeddingu = 1,18 GB. 1a. Przełącz na „Ternary Bonsai 2 27B”: 27 miliardów parametrów w 5,95 GB (9,14× mniej niż bf16), bo embedding też jest ternarny, a waga zajmuje 1,75 bita. Porównaj maksymalną prędkość (tok/s) z modelem 2B4T: jedenaście razy więcej parametrów (27,2 / 2,41), a plik tylko pięć razy większy.
  2. Przesuń suwak „w tym embedding i głowa” do 5%. O ile zmniejszy się plik? Tak wygląda model z mniejszym słownikiem.
  3. Przełącz „bity na wagę: warstwy” z 2 na 16 (czyli „ten sam model w bf16”) i zobacz, o ile spada maksymalna prędkość (tok/s).
  4. Ustaw model 70 mld parametrów i sprawdź, która z sześciu maszyn go w ogóle zmieści. 4a. Wybierz z listy „Kimi K3” i sprawdź w sekcji 1, ile zająłby w 2 bitach, a ile w fp16. Potem zobacz w sekcji 3, dlaczego model MoE (mieszanina ekspertów) odpowiada szybciej, niż sugeruje jego rozmiar.
  5. Porównaj wiersz „ternarny na 2 bitach” z „ternarny, minimum teoretyczne” w tabeli „Ile miejsca zajmuje waga”: 26% narzutu ponad granicę. Czy warto? (Odpowiedź w odcinku 07.)

Sprawdź się

Bez zaglądania w tekst i bez strony. Zapisz odpowiedź, dopiero potem rozwiń. To, czym Twoja odpowiedź różni się od tej pod spodem, to najcenniejsza rzecz z tego odcinka – zapisz to w dzienniku.

  1. Model 8 GB na maszynie z przepustowością pamięci 273 GB/s: jaka jest maksymalna prędkość (tok/s) przy batchu 1?
odpowiedź273 / 8 ≈ **34 tok/s**. To górna granica, prawdziwy system osiąga jej ułamek.
  1. Dlaczego plik 2B4T jest ok. 4×, a nie 8× mniejszy od wersji bf16?
odpowiedźBo 328 mln wag embeddingu (współdzielonych z głową) zostaje w F16: 657 MB przy 521 MB wag ternarnych. 8× dotyczy tylko warstw ternarnych.
  1. Ile bitów informacji niesie waga ternarna i skąd się bierze „26% narzutu”?
odpowiedźlog₂ 3 = 1,585 bita; zapis jest na 2 bitach, 2 / 1,585 = 1,26 → 26% ponad granicę.
  1. Czym się różni QAT od naiwnego PTQ i co pokazał pomiar na własnych modelach serii?
odpowiedźQAT trenuje z kwantyzacją w pętli (STE), PTQ zaokrągla po treningu. Pomiar: MLP na spirali 99,6% → 74,2%; bitGPT-nano: strata 0,39 → 2,79 (losowe zgadywanie: 3,22; QAT: 0,46).
  1. Jakie są dwa cele projektu i który z nich cudzy plik GGUF potwierdza, a którego nie zastępuje?
odpowiedź(1) zrozumieć sieć od środka, (2) duże modele na skromnym sprzęcie. Cudzy plik potwierdza (2) i nic nie mówi o (1).

Czego się nauczyłeś

  • Rozmiar modelu w bajtach to nie ciekawostka. Wyznacza maksymalną prędkość generowania, bo zysk nie bierze się z liczby operacji, tylko z przepustowości pamięci. Przy okazji znikają mnożenia.
  • Waga ternarna niesie 1,585 bita (log₂ 3, trzy stany wagi), ale zapisuję ją na 2 bitach z 26% narzutu. Świadomie, dla szybkości dekodowania.
  • W BitNecie embedding i głowa zostają w wysokiej precyzji, więc „model 2B zajmuje 0,5 GB” to zdanie o samych warstwach, a nie o pliku. Uczciwy rachunek rozmiaru zawsze zawiera embedding: 2B4T to 1,18 GB.
  • Naiwne zaokrąglenie gotowego modelu nie działa i dlatego BitNet trenuje z kwantyzacją od początku (QAT). Ale kompresja potreningowa z rotacją Hadamarda (Bonsai 2) dochodzi do 98,2% jakości przy pliku 9× mniejszym. „Ternarne” to dziś dwie szkoły, a nie jedna: trening od zera (ta seria) i kwantyzacja po treningu z rotacją (Bonsai). Druga szybciej daje gotowy plik, pierwsza uczy.
  • Ternaryzacja embeddingu i głowy jest możliwa (Bonsai robi to „end-to-end”). Zostawianie ich w wysokiej precyzji to wybór BitNeta, uzasadniony treningiem od zera.
  • DGX Spark ma tę samą przepustowość pamięci co M4 Pro. Przy samym generowaniu płacisz w nim za pojemność pamięci, a nie za prędkość.
  • Sukcesem tego projektu jest kompetencja i działające demo każdego kroku, a nie miejsce w rankingu.

W następnym odcinku biorę na warsztat same liczby: fp32, bf16, int8 i ile błędu dokłada kwantyzacja, kiedy wybierasz skalę. CDN…

Źródła

  • arXiv:2402.17764 – The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits (β = mean|W|, energia 71,4× jako oszacowanie).
  • arXiv:2310.11453 – BitNet: Scaling 1-bit Transformers §2 (powód wysokiej precyzji embeddingu i głowy: próbkowanie).
  • arXiv:2407.12327, 2506.23025 – Spectra / TriLM (FloatLM vs QuantLM vs TriLM); arXiv:2504.18415 – BitNet v2 (Hadamard w QAT); arXiv:2510.13998 – BitNet Distillation; arXiv:2502.02631 – ParetoQ; Falcon-E (TII, blog HF tiiuae/falcon-edge).
  • ggml-org/llama.cpp PR #1684 (k-quants: Q4_K = 4,5 bpw, Q4_K_M dokłada Q6_K) – źródło poprawki wiersza 4-bit.
  • arXiv:2504.12285 – BitNet b1.58 2B4T Technical Report (architektura 2B4T).
  • Dane producentów: Apple (M4 Pro 273 GB/s), NVIDIA (RTX 4090 1008 GB/s – whitepaper Ada; A100 80 GB SXM 2039 GB/s, PCIe 1935 GB/s; DGX Spark 273 GB/s).
  • Rodzina Bonsai (PrismML): https://huggingface.co/prism-ml/Ternary-Bonsai-27B-gguf, https://huggingface.co/prism-ml/Ternary-Bonsai-2-27B-gguf, https://docs.prismml.com/models/bonsai-27b.

Następny wpis →

BitNet od zera – Liczby w sieci: fp32, bf16, int8 i błąd kwantyzacji

2026-11-11 · 8 min czytania

0 komentarzy

Zostaw komentarz

Twój adres email nie zostanie opublikowany. Wymagane pola są oznaczone *