Odcinek pomostowy między kwantyzacją a autogradem: budżet pamięci prawdziwego modelu.
Model ma 5,95 GB, Ty masz 16 GB RAM. Zmieści się? Zwykle odpowiedź brzmi „spróbuj i zobacz”, czyli trzydzieści minut pobierania, żeby dostać out of memory. A wystarczy przeczytać pierwsze kilkadziesiąt bajtów pliku, żeby wiedzieć przed pobraniem: ile zajmą wagi, ile dołoży pamięć podręczna kontekstu, co zrobi silnik przy ładowaniu i czy w ogóle zna ten format.
Objaśnienie. Plik z modelem to nie worek liczb, tylko coś ze spisem treści. Na jego początku siedzi nagłówek, w którym jest wprost napisane, ile jest tablic z wagami, jakiego są typu, ile bitów przypada na jedną wagę, ile model ma warstw i głów. Z tych kilku liczb policzysz zużycie pamięci z dokładnością do kilku procent, zanim cokolwiek uruchomisz. W tym odcinku uczę czytać ten spis treści i przeliczać go na „zmieści się / nie zmieści się”. Przydaje się to przy każdym modelu, a nie tylko przy ternarnym.
Co ten odcinek dodaje do serii: 7 pakowanie pokaże, jak wygląda bajt wag od środka, a 16 bitnet cpp w którym zaglądam, co konkretnie jest zapisane w oficjalnym pliku BitNeta i w jakim stanie jest ekosystem, przyjdzie dalej. Tutaj chodzi o trzecią rzecz, czysto praktyczną: przewidzieć zużycie pamięci z nagłówka i zrozumieć, co się dzieje między plikiem na dysku a obliczeniami. Bez treningu i bez GPU.
Strona projektu: Budżet pamięci: czy ten model się zmieści?
1. Nagłówek GGUF: spis treści pliku
Plik GGUF zaczyna się od stałej struktury, którą da się odczytać w ok. 150 wierszach kodu:
magic "GGUF" (4 B) · wersja (u32) · liczba tensorów (u64) · liczba par metadanych (u64)
→ pary klucz-wartość (architektura, liczba warstw, głowy, kontekst, tokenizer, …)
→ indeks tensorów (nazwa, kształt, typ ggml, offset)
→ wyrównanie → blob z danymi
Najważniejsze: indeks tensorów podaje typ każdego z nich osobno. Model nie ma „jednej kwantyzacji”. Zwykle ma ich kilka naraz i to jest główne źródło pomyłek przy szacowaniu rozmiaru.
Przykład odczytu (zmierzone: ggml-model-i2_s.gguf z microsoft/bitnet-b1.58-2B-4T-gguf, 1 187 801 280 B – ten sam odczyt robi inspektor na stronie 12 z odcinka 16):
| co | wartość |
|---|---|
| format | GGUF v3, 332 tensory, 24 pary metadanych |
| architektura | bitnet-b1.58, warstw 30, d_model 2560 |
| głowy | 20 Q / 5 KV (GQA), kontekst 4096 |
| tensory ternarne | 210 × typ 36 (I2_S), razem 2 084 044 800 wag |
| normalizacje | 121 × F32 |
| embedding | 1 × F16, 2560 × 128 256 |
| głowa | brak output.weight → współdzieli wagi z embeddingiem |
2. Ile bitów naprawdę zajmuje jedna waga
Tabela, którą dobrze mieć pod ręką. Te same {−1, 0, +1} pakowane na pięć sposobów:
| format | bity/wagę | gdzie |
|---|---|---|
.bitpack (nasz, odc. 07) |
2,0 | ten projekt – czytelność ważniejsza niż gęstość |
| I2_S (typ 36) | 2,0 + jedna skala f32 na tensor (zapisana na końcu, 32 B) | fork bitnet.cpp, nie ma go w głównej gałęzi llama.cpp |
TQ2_0 (typ 35) |
2,0625 | llama.cpp, główna gałąź |
TQ1_0 (typ 34) |
1,6875 | llama.cpp, główna gałąź |
PTQ1_0 |
1,75 w formacie wdrożeniowym | Ternary Bonsai 2 (PrismML) |
| granica teoretyczna | log₂3 = 1,585 | trzy stany na wagę |
(źródło: llama.cpp PR #8151 dla TQ1_0/TQ2_0; karty modeli PrismML dla PTQ1_0)
Dwa wnioski. Po pierwsze: moje 2 bity to o 26% więcej niż granica informacyjna, a przy modelu z 27 mld parametrów to mniej więcej gigabajt różnicy. Płacę tę cenę świadomie, w zamian za dekodowanie jednym przesunięciem bitowym. Po drugie: 2 bity na wagę to nie 2 bity na parametr modelu, bo embedding zwykle nie jest ternarny. Na tym polega pułapka z następnej sekcji.
3. Budżet pamięci z nagłówka
Trzy składniki, od najważniejszego:
wagi ternarne = liczba_wag_ternarnych × bity/wagę / 8
+ embedding = vocab × d_model × bajty_typu_embeddingu ← najczęściej pomijany
+ cache KV = 2 × warstwy × głowy_KV × d_head × bajty × kontekst
Rachunek dla 2B4T (wszystkie liczby z nagłówka pokazanego wyżej):
| składnik | rachunek | wynik |
|---|---|---|
| wagi ternarne | 2 084 044 800 × 2 / 8 | 521 MB |
| embedding F16 | 2560 × 128 256 × 2 B | 657 MB |
| normalizacje F32 | 121 tensorów | ok. 1 MB |
| cache KV przy 4096 tokenach, f16 | 2 × 30 × 5 × 128 × 2 B × 4096 | 315 MB |
| razem | ≈ 1,49 GB |
Same wagi to 1178 MB przy pliku o rozmiarze 1188 MB. Resztę zajmują metadane, głównie słownik 128 256 tokenów.
Pułapka, którą dobrze zobaczyć raz a porządnie. Zdanie „model 2B w 1,58 bita zajmuje pół giga” jest prawdziwe tylko w odniesieniu do warstw ternarnych. Same wagi to 1,18 GB (cały plik z metadanymi: 1,19 GB), a w pamięci razem z kontekstem ok. 1,49 GB, czyli trzy razy więcej, niż obiecuje slogan. Winny jest embedding: 328 mln parametrów w F16, czyli więcej bajtów niż wszystkie 2,08 mld wag ternarnych razem wzięte. Stąd bierze się większość zaskoczeń typu „miało się zmieścić”.
Dla porównania Ternary Bonsai 2 27B: 27,2 mld parametrów × 1,75 bita / 8 ≈ 5,95 GB. Tyle daje kalkulator na stronie 01 (gotowe ustawienie 2,72·10¹⁰ parametrów, „9,14× mniej” niż bf16) (obliczone) i to jest już cały model, bo tu ternarne są także embedding i głowa (źródło: karta modelu). 5,91 GB w starszych tekstach to wynik dla ustawienia 27,0 mld. Cache KV dolicz według wzoru wyżej, z liczbami z nagłówka.
4. Co się dzieje między plikiem a obliczeniami
Nagłówek mówi, ile jest bajtów. Nie mówi, jak trafią do obliczeń, a od tego może zależeć zużycie pamięci i czas startu. Silnik llama-server ma do tego jedną opcję (cytaty z --help pliku wykonywalnego z pakietu Ollamy 0.34.0, zmierzone):
--load-mode |
co robi |
|---|---|
auto (domyślne) |
mmap, chyba że urządzenie go nie obsługuje |
none |
bez mmap – cały plik kopiowany do pamięci |
mmap |
plik „udaje” pamięć, system wczytuje potrzebne fragmenty |
mlock, mmap+mlock |
wymuszenie trzymania danych w RAM |
dio |
DirectIO, jeśli dostępne |
Jest też --lazy-mode, czyli „czytanie wierszy wybranych tensorów z dysku na żądanie”. Dwie rzeczy zmieniają oczekiwania. To nie jest strumieniowe wczytywanie całego modelu z SSD (w trybie auto dotyczy tylko tensorów powyżej 4 GiB). I wymaga mmap: wyłączenie mapowania wyłącza też tryb leniwy.
A teraz część, która mnie zaskoczyła: Ollama uruchamia dokładnie ten program jako proces potomny i sama ustala jego flagi. W poleceniu zapisanym w logu na tym komputerze nie ma ani jednej z powyższych opcji (zmierzone: ~/.ollama/logs/server.log). Co więcej, gdy model nie mieści się w pamięci GPU, Ollama sama dopisuje --load-mode none (reason=metal_partial_offload), a flaga z wiersza poleceń ma pierwszeństwo przed zmienną środowiskową. Silnik pisze to wprost w ostrzeżeniu. Czyli dokładnie wtedy, gdy mapowanie pliku by się przydało, nie włączysz go zmienną.
Jedyne ustawienie, na które masz faktyczny wpływ, to use_mmap w opcjach API i w Modelfile: false → Ollama dopisuje --load-mode none, true → nie dopisuje nic (zmierzone). Nie ma go w ollama serve --help, ale działa.
4.1 Czy to ustawienie wystarczy? Trzy części, trzy różne odpowiedzi
Naturalne pytanie: skoro Ollama sama wyłącza mapowanie, gdy tylko część warstw trafia na GPU (częściowy offload), to czy use_mmap: true odbierze jej tę decyzję? Odpowiedź trzeba sprawdzić osobno i właśnie tego uczy ta sekcja.
Część 1 – scheduler Ollamy: ustawienie działa. (zmierzone; częściowy offload wymuszony opcją num_gpu)
num_gpu |
use_mmap |
co robi Ollama |
|---|---|---|
| 10 (częściowy) | – | dopisuje --load-mode none |
| 10 (częściowy) | true |
nie dopisuje nic |
| 99 (pełny) | false |
dopisuje --load-mode none |
Pierwsze i drugie polecenie różnią się wyłącznie numerem portu i tą jedną flagą. Scheduler nie zapisuje w logu nawet swojej decyzji.
Część 2 – silnik: zależy od architektury modelu. Silnik z pakietu Ollamy ma własną łatę, która dla niektórych modeli i tak wyłącza mmap:
compat patch disabled mmap for transformed text tensors
(zmierzone, żądanie przez Ollamę z use_mmap: true):
| model | architektura | łata | co raportuje silnik |
|---|---|---|---|
qwen2.5-coder:1.5b-base |
qwen2 |
nie | load_mode = mmap |
gemma4 |
gemma4 |
nie | load_mode = mmap |
gpt-oss:20b |
gptoss |
nie | load_mode = mmap |
qwen3.5:4b, qwen3.5:9b |
qwen35 |
tak | load_mode = none |
qwen3.6:35b |
qwen35moe |
tak | load_mode = none |
Tekst tego komunikatu siedzi w pliku wykonywalnym llama-server z pakietu Ollamy, a nie ma go w libllama-server-impl.dylib. Czyli to łata nałożona przez Ollamę na llama.cpp, a nie zachowanie głównej gałęzi.
Jak się pomyliłem i czego to uczy. Dzień wcześniej zmierzyłem to samo na trzech modelach Qwen 3.5/3.6, zobaczyłem
load_mode = nonew każdym przebiegu i napisałem tu: „mmap pod Ollamą i tak się nie włączy”. To było zbyt daleko idące uogólnienie z próby złożonej z samych Qwenów. Wystarczyło dołożyćgemma4igpt-oss, żeby zobaczyćmmap. Jeżeli wszystkie Twoje przypadki testowe pochodzą z jednej rodziny, nie mierzysz zachowania narzędzia, tylko zachowanie tej rodziny.
Część 3 – tryb leniwy: działa, i to niezależnie od mmap. Tu z kolei zmyliła mnie dokumentacja. --help mówi, że --lazy-mode on „requires mmap”, więc wyciągnąłem wniosek, że skoro Ollama wyłącza mmap, to tryb leniwy jest nieosiągalny. Pomiar pokazuje co innego (zmierzone na gemma4, który ma tensor per_layer_token_embd.weight o rozmiarze 5376 MiB – powyżej progu 4 GiB):
--load-mode |
--lazy-mode |
szczytowe zużycie pamięci przez proces |
|---|---|---|
mmap |
off |
9,81 GB |
mmap |
on |
3,84 GB |
none |
on |
4,34 GB |
none |
off |
9,98 GB |
Oszczędność to około 6 GB, dokładnie tyle, ile zajmuje tensor zostawiony na dysku. Czas startu się przy tym nie zmienia (1,6 s w obu wariantach). W pierwszej serii wyszło 5,7 s dla trybu leniwego i 1,6 s dla zwykłego, ale winna była zimna pamięć podręczna stron (page cache), co widać po odwróceniu kolejności pomiarów. Gdybym zmierzył tylko raz, opisałbym tu nieistniejące spowolnienie 3,5×.
Wniosek praktyczny. use_mmap działa w Ollamie dla większości modeli, a w rodzinie qwen35 blokuje je łata. Tryb leniwy, który (jak właśnie widać) naprawdę oszczędza pamięć, jest w Ollamie nieosiągalny, ale nie dlatego, że brakuje mmap. Ollama po prostu nigdy nie przekazuje tej flagi (w jej pliku wykonywalnym tekst lazy-mode nie występuje ani razu). Jak chcesz go użyć, odpal llama-server samodzielnie.
Dwie lekcje, obie ważne nie tylko w tym przypadku.
- Sprawdzaj warstwę, na której coś się dzieje. Polecenie uruchamiające proces potomny mówiło „mmap włączony”, a przy Qwenach mapowania nie było. Miarodajny jest wiersz
load_mode = …z logu silnika, bo to silnik czyta plik.- Zdanie z dokumentacji to nie pomiar. „requires mmap” brzmiało jak fakt i zbudowałem na nim cały łańcuch wniosków. Trzydzieści sekund pracy programu pokazało, że tryb leniwy działa także bez mmap.
Zastrzeżenia: jedna platforma, jedna wersja (Ollama 0.34.0). Nie zmierzyłem, ile tryb leniwy kosztuje w tokenach na sekundę. Tensor czytany z dysku w trakcie obliczeń musi coś kosztować.
5. Czego nagłówek Ci nie powie
- Czy Twój silnik w ogóle zna ten typ. I2_S (typ 36) nie istnieje w głównej gałęzi llama.cpp, to typ z forka Microsoftu. Ollama i LM Studio go nie wczytają (zgłoszenia ollama #10337 i #8970 są otwarte).
TQ2_0działa, w tym na Metalu (PR #26980), a dla CUDA dalej brak obsługi TQ. - Że ten sam model to inny plik na x86 i na ARM. I2_S układa wagi w bloki po 128 na x86 i po 64 na ARM, a oficjalny konwerter zawsze pakuje w układzie dla x86 (odc. 07). To jedna z czterech hipotez wyjaśniających bezsensowny tekst na wyjściu na Apple Silicon. Pozostałe to gałąź submodułu, SiLU zamiast ReLU² w grafie forka (z dowodem w kodzie źródłowym) i błędna ścieżka zapasowa bez instrukcji wektorowych (scalar fallback, #600).
- Buforów obliczeniowych i narzutu środowiska. Rachunek z §3 to dolna granica, a prawdziwe zużycie zmierzysz dopiero po starcie (
RSS, log silnika). Dlatego „przewidziane a zmierzone” to osobny krok tego odcinka. Cel to zgodność ±10%, a rozjazdy się opisuje, zamiast naginać wzór.
5.1 Przewidziane a zmierzone – pomiar na trzech własnych plikach
Objaśnienie. W końcu sprawdziłem, jak rachunek z §3 ma się do rzeczywistości: trzy modele z dysku uruchomione bezpośrednio w silniku (bez Ollamy), w trzech trybach ładowania, z odczytem pamięci procesu. Wniosek w jednym zdaniu: rachunek zgadza się z dokładnością do kilku procent, kiedy plik jest kopiowany do pamięci, a architektura jest „zwykła”. Myli się o jedną piątą, gdy model ma nietypowy mechanizm uwagi (attention), i wtedy wiadomo, który składnik wzoru poprawić.
Zmierzone skryptem pomiarowym; silnik llama-server z pakietu Ollamy uruchamiany bezpośrednio, kontekst 2048, cache f16, narzut 0,5 GB [szacunek]:
| model (plik) | razem przewidziane | RSS load_mode = none |
rozjazd | RSS mmap |
tok/s (none / mmap) |
|---|---|---|---|---|---|
| qwen2.5-coder 1,5b (0,99 GB) | 1,54 GB | 1,57 GB | +1,8% | 1,17 GB | 153 / 152 |
| qwen3.5 4b (3,39 GB) | 4,96 GB | 4,02 GB | −19,1% | 4,02 GB (łata wyłącza mmap) | 60 / 62 |
| ornith 9b (5,63 GB) | 6,40 GB | 6,82 GB | +6,6% | 5,84 GB | 38,5 / 39,4 |
- Cel ±10% z punktu 3 wyżej spełniają 2 z 3 pomiarów. Rozjazd w trzecim przypadku wynika ze składnika KV. Wzór liczy cache dla każdej warstwy, a
qwen3.5ma warstwy hybrydowe bez klasycznego cache’u K/V [hipoteza – do sprawdzenia tensor po tensorze]. Dla tej rodziny silnik z pakietu Ollamy wyłącza mmap niezależnie od flagi (compat patch disabled mmap for transformed text tensorsw logu przy--load-mode mmap). - Tryb ładowania nie zmienia szybkości pracy (tok/s i TTFT równe w granicach ±3%), zmienia tylko to, co pokazuje RSS. Przy
mmapwidać strony pliku, które zostały faktycznie odczytane (o 4-18% więcej niż rozmiar pliku), przynonekopię wag i bufory. Właśnie dlatego trzy piętra z §4.1 (cmd=,load_mode, RSS) czyta się osobno. --lazy-mode onnie włączył się dla żadnego z trzech plików (brak tensora ≥ 4 GiB), więc koszt trybu leniwego w tok/s dalej nie jest zmierzony.
Ćwiczenie na stronie
Dwie strony: 02b-budzet-pamieci.html, czyli kalkulator „czy się zmieści” z listą przykładowych modeli i wyborem rodzaju uwagi, oraz 12-hub.html, czyli inspektor nagłówka, który czyta Twój plik lokalnie w przeglądarce (nic nie wysyła).
- Wskaż w inspektorze (strona 12, odc. 16) dowolny plik
.gguf, który masz na dysku, choćby zwykłyQ4_K_M. Odczytaj liczbę tensorów, rozkład typów i architekturę. - W polu „Tensory po nazwie” wpisz
token_embd, a dostaniesz typ i kształt embeddingu. Policz sam, ile miejsca zajmuje (elementy × bajty typu) i jaki to procent całego pliku. (Przykład z prawdziwego pliku:qwen35, embeddingQ6_K2560 × 248 320 = 636 mln parametrów w modelu o rozmiarze 3,39 GB.) - Liczby odczytane w inspektorze (warstwy, głowy KV, wymiar głowy) przepisz do kalkulatora (strona 02b, odc. 03) albo wybierz z listy podobny model. Ustaw pamięć swojego komputera i przesuwaj suwak długości kontekstu. Znajdź punkt, w którym cache KV zaczyna zajmować więcej miejsca w pamięci niż model. Dla 2B4T to ≈ 15 000 tokenów (76 800 B na token × 15 334 = 1,18 GB wag) (poprawione: poprzednia wersja podawała 32 768 – błąd 2×), a dla modelu z dużą liczbą głów KV dużo wcześniej.
- Na tej samej stronie przełącz format cache’u na
q4_0. Dla 2B4T przy 131 072 tokenach cache maleje z 10,07 GB do 2,83 GB. To efekt tej jednej flagi-ctk q4_0, o której nie wspomina żaden poradnik o „modelach na słabym sprzęcie”. - W sekcji 5 kalkulatora zobacz, ile ten sam model zająłby z innym rodzajem uwagi. Przy wymiarach Llama 3.1 8B i 4096 tokenach MLA (jak w DeepSeek-V3) trzyma w cache’u 14 razy mniej niż pełne MHA, a okno przesuwne w połowie warstw (jak w gpt-oss) prawie 8 razy mniej (obliczenie na stronie).
- Odpal model naprawdę i porównaj przewidywanie z faktycznym zużyciem pamięci. Rozjazd większy niż 10%? Zapisz, jak duży, bo to jest właśnie ta liczba, której nie ma w żadnym poradniku.
- Sprawdź §4.1 u siebie: odpal model w Ollamie i znajdź w
~/.ollama/logs/server.logdwa wiersze:cmd=(co Ollama zleciła) iload_tensors: … (load_mode = …)(co silnik zrobił). Jeżeli różnią się mimouse_mmap: true, masz tę samą łatę co ja. Jeżeli nie, napisz, na jakiej platformie i w jakiej wersji, bo to rozstrzyga pytanie oznaczone u mnie jako niezweryfikowane.
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, ile bajtów zajmuje cache KV na jeden token dla 2B4T (30 warstw, 5 głów KV, wymiar głowy 128, f16), i podaj kontekst, przy którym cache dorównuje wagom (1,18 GB).
odpowiedź
2·30·5·128·2 B = **76 800 B/token**; 1177,7 MB / 76 800 ≈ **15 300 tokenów**.- Dlaczego embedding liczy się w budżecie osobno?
odpowiedź
Ma inny typ (F16/Q6_K) niż warstwy i często zajmuje więcej miejsca niż wszystkie warstwy razem: w 2B4T 657 MB wobec 521 MB. Pominięcie go to najczęstsze źródło błędu „2B = 0,5 GB”.- Dlaczego jeden plik GGUF nie ma „jednej kwantyzacji”?
odpowiedź
Nagłówek podaje typ **każdego** tensora z osobna: embedding może być w Q6_K, warstwy w Q4_K, normalizacje w F32. Rozmiar liczy się dla każdego typu osobno: bajty typu × liczba elementów.- Trzy piętra przy uruchamianiu modelu: co mierzy wiersz
cmd=, coload_mode = …, a co RSS?
odpowiedź
`cmd=` to to, co Ollama *zleciła*; `load_mode` w logu silnika to to, co llama-server *zrobił* (łata compat może to zmienić); RSS/footprint to to, co system *faktycznie* trzyma w pamięci. Miarodajne jest piętro najniższe.Czego się nauczyłeś
- Nagłówek GGUF to spis treści: typ każdego tensora z osobna, architektura, głowy, kontekst. Wszystko, czego trzeba do policzenia budżetu pamięci.
- Budżet = wagi + embedding osobno + cache KV. Pominięcie embeddingu to najczęstszy błąd: w 2B4T zajmuje on więcej miejsca niż 2,08 mld wag ternarnych razem.
- Cache KV rośnie liniowo z długością kontekstu, a wagi wcale. Dla 2B4T przy 4096 tokenach cache to 21% sumy wag i cache’u (9%, jeśli doliczyć 2 GB narzutu
[szacunek]ze strony), przy 131 072 to już 90% (76% z narzutem). Przy długim kontekście o tym, czy model się zmieści, decyduje cache, a nie model. Dlatego kwantyzacja cache’u (q8_0,q4_0) daje czasem większą oszczędność niż kwantyzacja wag. - Formaty ternarne różnią się gęstością: 1,6875 (
TQ1_0), 1,75 (PTQ1_0), 2,0 (.bitpack, I2_S), 2,0625 (TQ2_0), przy granicy log₂3 = 1,585. - Między plikiem a obliczeniami stoi tryb ładowania (
--load-mode, mmap,--lazy-mode), a w Ollamie większość tych decyzji podejmuje za Ciebie scheduler. use_mmap: truenaprawdę odbiera Ollamie jej automatyczną decyzję i dla większości architektur mmap się wtedy włącza. Rodzinęqwen35blokuje osobna łata w silniku. Miarodajny jest wierszload_mode = …z logu silnika, a nie polecenie uruchamiające proces.- Tryb leniwy (
--lazy-mode on) zmniejsza zużycie pamięci dokładnie o tyle, ile zajmuje tensor zostawiony na dysku (nagemma49,81 GB → 3,84 GB), i nie wymaga mmap, wbrew własnej dokumentacji. W Ollamie i tak go nie użyjesz, bo nigdy nie przekazuje ona tej flagi. - Rozmiar to nie wszystko: silnik musi znać typ, a I2_S zna tylko fork.
W następnym odcinku zaczynam budować od zera: własny mikroautograd, czyli backward() bez magii, i pierwsza sieć ucząca się na spirali i MNIST. CDN…
Źródła
- Formaty ternarne: llama.cpp PR #8151 (
TQ1_01,6875 bpw,TQ2_02,0625 bpw), PR #26980 (Metal TQ2_0); karty modeli PrismML (PTQ1_0, Ternary Bonsai 2 27B). - I2_S: microsoft/BitNet commit 0b341e5 (
quantize_to_i2_s,ggml-cpu-i2s.c), zgłoszenia #600, #610, #618; szczegóły układu bajtów.
0 komentarzy