wszystkie wpisy 2026 BitNet
BitNet · 2026-10-30 · 9 min

BitNet od zera – Test: czy Twoja przeglądarka uruchomi BitNet?

Tak na szybko, zanim napiszę cokolwiek o sieciach neuronowych: sprawdźmy, czy Twoja przeglądarka w ogóle pociągnie tę serię. Brzmi niewinnie, ale od odpowiedzi zależy, ile odcinków części I zobaczysz w akcji, a ile tylko jako tabelkę. Cały test mieści się w jednym zdaniu: cztery wagi, cztery liczby, ma wyjść 80.

Objaśnienie. Przeglądarka od kilku lat umie korzystać z karty graficznej – tego samego układu, który rysuje Ci grafikę w grach. Nazywa się to WebGPU i pozwala odpalić własny mały program (kernel), który liczy na tysiącach rdzeni naraz. Ta strona sprawdza, czy Twoja przeglądarka to potrafi, i od razu daje karcie najprostsze zadanie z całej serii. Wynik ma być dokładnie liczbą całkowitą 80, a nie „coś koło 80”. Jak nie masz WebGPU, nic się nie sypie: wszystko policzy procesor, tylko wolniej.

Strona z kodem: Test: czy Twoja przeglądarka uruchomi BitNet?

1. Co to jest WebGPU i czemu akurat ono

WebGPU to standard W3C (Candidate Recommendation Draft), który daje stronie dostęp do karty graficznej: bufory pamięci, potoki obliczeniowe i język shaderów WGSL. W praktyce wygląda to tak:

  • Chrome/Edge mają WebGPU włączone domyślnie od wersji 113 (źródło: developer.chrome.com, wpis „WebGPU ships in Chrome 113”).
  • Safari dostało je w wersji 26 – na macOS z dopiskiem „obsługa częściowa” (źródło: caniuse.com/webgpu).
  • Firefox na macOS w chwili pisania nie ma go włączonego domyślnie (źródło: caniuse.com/webgpu).

Czemu mi na tym zależy? Bo cała seria stoi na tym, że liczysz sam, u siebie. Nic nie leci na serwer, nie ma klucza API, nie zakładasz konta. To, co widzisz na wykresie, powstało na Twoim sprzęcie. A jak wyjdzie Ci inaczej niż mnie w artykule, to jest informacja, a nie awaria.

Drugi powód jest mniej oczywisty. BitNet to architektura, w której mnożenie znika z warstw ternarnych, czyli z 97% wag (ale nie z całego modelu – embedding, głowa, uwaga, normalizacje i sama dekwantyzacja dalej mnożą liczby ułamkowe). Wagi w tych warstwach mają tylko trzy wartości: -1, 0, +1. „Mnożenie” robi się więc z dodania, pominięcia albo odjęcia liczby. To robota dla arytmetyki całkowitej, a nie zmiennoprzecinkowej… i akurat tu karta graficzna ma instrukcje, o których większość programistów nigdy nie słyszała (o dot4I8Packed za chwilę).

2. Co dokładnie sprawdza test

Strona sprawdza pięć rzeczy i wypluwa wszystko w jednym raporcie JSON. Jak coś nie działa, kopiujesz i wklejasz.

Co Po co mi to w tej serii
navigator.gpu istnieje bez tego nie ma WebGPU; seria działa, ale na procesorze
adapter (producent / architektura) mówi, jaką kartę faktycznie dostałeś
cechy adaptera interesują mnie timestamp-query (pomiar czasu na GPU) i shader-f16
cecha języka WGSL packed_4x8_integer_dot_product daje dot4I8Packed – cztery mnożenia int8 w jednej instrukcji (odcinek 08)
limity ile wątków wejdzie do grupy roboczej i jak duży bufor da się podpiąć

Na macu wychodzi tak:

adapter:                       apple / metal-3
timestamp-query:               jest
shader-f16, subgroups:         jest
packed_4x8_integer_dot_product: jest
maxComputeInvocationsPerWorkgroup: 1024
maxComputeWorkgroupStorageSize:    32768 B
maxStorageBufferBindingSize:       4 294 967 292 B (~4 GB)

Na laptopie z kartą NVIDIA GeForce RTX 4090 Laptop GPU (Chrome 151, Windows, WebGPU przez D3D12, zasilacz) strona pokazuje nvidia / lovelace, te same cechy (timestamp-query, shader-f16, subgroups, packed_4x8_integer_dot_product) i te same limity grupy roboczej: 1024 wątki i 32768 B. Inny jest tylko największy bufor: 2 147 483 644 B (~2 GB), połowa tego, co na Macu.

Bez niespodzianek, poza jedną: WebGPU nie da się wyłączyć nagłówkiem Permissions-Policy, tak jak kamery czy mikrofonu. Jedyny warunek to bezpieczny kontekst (HTTPS albo localhost) (źródło: specyfikacja W3C WebGPU, rozdział o bezpieczeństwie). W praktyce: strona zadziała też wtedy, gdy wkleisz ją na dowolną inną stronę.

3. Wektor wzorcowy: cztery liczby, które będą wracać przez całą serię

Na czynniki pierwsze rozbiorę je w odcinku 06, ale pokażę je już teraz, bo od tej chwili każdy kolejny odcinek musi się z nimi zgadzać. To jest nasz wektor wzorcowy (golden vector):

W = [ 0,31   −0,04   0,27   −0,45 ]      wagi (liczby ułamkowe)
h = [ 0,5    −2,0    1,0     0,25 ]      wejście

β = mean|W| = 0,2675                     jedna skala na cały tensor wag
Ŵ = clip(round(W/β), −1, 1) = [1, 0, 1, −1]

γ = max|h| = 2,0                         jedna skala na token
x̂ = clip(round(h·127/γ), −127, 127) = [32, −127, 64, 16]

acc = 1·32 + 0·(−127) + 1·64 + (−1)·16 = 80        ← tylko liczby całkowite
y   = acc · β · γ / 127 = 0,337008

Zwróć uwagę na acc = 80. To nie jest przybliżenie. Cztery różne implementacje – naiwny JavaScript, wersja tablicowa, shader WGSL i shader z dot4I8Packed – muszą dać tę samą liczbę całkowitą. Jak któraś da 79 albo 81, to masz błąd w kernelu, a nie „szum numeryczny”. Arytmetyka całkowita nie zna „prawie dobrze” i to jest najważniejsze narzędzie do szukania błędów w całej serii. Wrócę do tego w odcinkach 07, 08 i 12.

Te cztery wagi mieszczą się w jednym bajcie: 0x91. W odcinku 07 zobaczysz, czemu akurat takim i czemu bitnet.cpp zapisałby go zupełnie inaczej.

Wynik u mnie

Na RTX 4090 Laptop też wychodzi cztery na cztery, każdy silnik daje acc = 80: js_naive 0,000 ms, js_lut 0,100 ms, webgpu 0,066 ms, webgpu_dp4a 0,066 ms. Oba czasy karty to dokładnie 65,536 µs, czyli jeden krok zegara, do którego Chrome zaokrągla tu znaczniki czasu karty. Te cztery mnożenia trwają krócej niż jeden krok, więc z tych liczb wynika tylko tyle, że silniki działają i się zgadzają. Porównywać czasów z M4 Pro nie ma sensu.

4. Kernel, czyli co się naprawdę wykonało

Cały program na GPU, który policzył tę osiemdziesiątkę, ma kilkanaście linijek:

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) globalInvocationId: vec3
<u32>) {
  let row = globalInvocationId.x;
  if (row >= gemvDims.m) {
    return;
  }
  let wordsPerRow = gemvDims.words;
  var acc: i32 = 0;
  for (var wordIndex: u32 = 0u; wordIndex < wordsPerRow; wordIndex = wordIndex + 1u) {
    let word = gemvW[row * wordsPerRow + wordIndex];   // 16 wag w jednym u32
    let base = wordIndex * 16u;
    for (var codeIndex: u32 = 0u; codeIndex < 16u; codeIndex = codeIndex + 1u) {
      let code = (word >> (codeIndex * 2u)) & 3u;      // 2 bity = jedna waga
      let activation = gemvX[base + codeIndex];
      if (code == 1u) {
        acc = acc + activation;                        // +1
      } else if (code == 2u) {
        acc = acc - activation;                        // −1
      }
      // code == 0u → waga zerowa, nic nie robimy
    }
  }
  gemvY[row] = acc;
}

I to jest dosłownie cały BitNet w kodzie: dodaj, pomiń albo odejmij. Ani jednego mnożenia. Wersja z dot4I8Packed robi to samo, tylko rozpakowuje cztery kody do czterech bajtów i wywołuje jedną instrukcję sprzętową (to samo, co dp4a w CUDA – na tym jedzie kernel GPU Microsoftu).

5. Jak nie masz WebGPU

Strona wypisze wtedy „brak WebGPU (navigator.gpu)” i policzy wszystko w JavaScripcie. Co to znaczy dla serii:

  • odcinki 00-07, 09, 10, 11 działają bez różnicy (tam GPU i tak nic nie liczy),
  • odcinek 08 zmierzy dwa silniki zamiast czterech (wiersze WebGPU będą oznaczone jako pominięte),
  • odcinek 12 wygeneruje tekst wolniej, ale identycznie co do bitu (i to jest całe piękno arytmetyki całkowitej).

Krótko: bez WebGPU tracisz szybkość, a nie treść.

Ćwiczenie na stronie

  1. Odpal test i sprawdź, czy wszystkie dostępne silniki dają 80.
  2. Skopiuj raport JSON i porównaj limity z moimi: masz też maxComputeInvocationsPerWorkgroup równe 1024?
  3. Sprawdź packed_4x8_integer_dot_product. Jak masz „brak”, to w odcinku 08 zmierzysz trzy silniki, a wiersz webgpu_dp4a będzie oznaczony jako pominięty; reszta serii bez zmian.
  4. Jak masz drugą przeglądarkę, odpal test i tam, i porównaj raporty. Safari i Chrome na tym samym Macu potrafią zgłaszać różne zestawy cech.

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. Policz z pamięci acc wektora wzorcowego z Ŵ = [1, 0, 1, −1] i x̂ = [32, −127, 64, 16].
odpowiedź32·1 + (−127)·0 + 64·1 + 16·(−1) = 32 + 64 − 16 = **80**.
  1. Czemu wynik na GPU musi być identyczny z wynikiem w JavaScripcie, a nie tylko „bliski”?
odpowiedźBo to arytmetyka całkowita: int8 × {−1,0,+1} sumowane do int32 nie ma zaokrągleń ani zależności od kolejności sumowania. Różnica = błąd w kernelu, a nie „szum numeryczny”.
  1. Z których części modelu mnożenie nie znika?
odpowiedźZ embeddingu i głowy (F16), z uwagi (QKᵀ, PV), z normalizacji, z softmaxu i z samej dekwantyzacji `acc·β·γ/127`. Znika tylko z warstw ternarnych – 97% wag, a nie 100% obliczeń.
  1. Co sprawdza test poza samym tym, czy jest WebGPU, i po co?
odpowiedźCechę `packed_4x8_integer_dot_product` (`dot4I8Packed`) – bez niej wiersza `webgpu_dp4a` w odcinku 08 po prostu nie ma; a do tego to, czy kernel dla K = 4 się kompiluje i daje oczekiwane 80.

Czego się nauczyłeś

  • Przeglądarka umie liczyć na GPU (WebGPU, WGSL) i nie potrzebuje do tego nic poza bezpiecznym kontekstem.
  • BitNet zamienia mnożenie na dodawanie i odejmowanie, bo waga ma tylko trzy wartości.
  • Wynik pośredni to liczba całkowita, więc różne implementacje muszą się zgadzać dokładnie – to jest mój główny test poprawności w kolejnych odcinkach części I.
  • Wektor wzorcowy serii: W, h, β = 0,2675, Ŵ = [1, 0, 1, −1], γ = 2,0, x̂ = [32, −127, 64, 16], acc = 80, y ≈ 0,337, bajt 0x91.

W następnym odcinku: po co to wszystko, czyli ile naprawdę oszczędzasz, jak waga ma 1,58 bita zamiast 16. CDN…

Źródła

  • W3C, WebGPU i WGSL, Candidate Recommendation Draft.
  • developer.chrome.com – „WebGPU ships in Chrome 113”.
  • caniuse.com/webgpu – stan obsługi w przeglądarkach.
  • Pomiary własne: strona https://czub.info/projects/bitnet/00-sonda/

Następny wpis →

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

2026-11-06 · 18 min czytania

0 komentarzy

Zostaw komentarz

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