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
- Odpal test i sprawdź, czy wszystkie dostępne silniki dają 80.
- Skopiuj raport JSON i porównaj limity z moimi: masz też
maxComputeInvocationsPerWorkgrouprówne 1024? - Sprawdź
packed_4x8_integer_dot_product. Jak masz „brak”, to w odcinku 08 zmierzysz trzy silniki, a wierszwebgpu_dp4abędzie oznaczony jako pominięty; reszta serii bez zmian. - 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.
- Policz z pamięci
accwektora wzorcowego zŴ = [1, 0, 1, −1]ix̂ = [32, −127, 64, 16].
odpowiedź
32·1 + (−127)·0 + 64·1 + 16·(−1) = 32 + 64 − 16 = **80**.- 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”.- 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ń.- 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, bajt0x91.
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/
0 komentarzy