wszystkie wpisy 2026 Programowanie
Programowanie · Sztuczne sieci neuronowe · 2026-05-10 · 9 min

Kwantyzacja dla opornych – czemu int4 nie przyspiesza generowania grafiki na GPU

Dawno nie było wpisu… na temat generowania grafiki. Ostatnio sobe siadłem fo starego codebase i porobiłem z ciekawości pipeline do kwantyzacji do modeli dyfuzyjnych – SDXL, FLUX, SD3, trochę video. Tak aby w praktyce zobaczyć kwantyzację, gdzie prawie każdy „tutorial” w internecie powtarza: że niższe bity = szybciej. No bo logiczne, nie? Mniej bitów do mnożenia, mniej roboty dla GPU, prędzej wypluje obrazek.

Tylko że… nie. I to nie jest drobny niuans, tylko fundamentalne nieporozumienie.

Pomiary robiłem na laptopie z RTX 4090 mobile (16 GB VRAM), Windows 11, CUDA 12.9, Python 3.14, diffusers 0.38, torch 2.5+. Konkretne liczby, na konkretnej karcie. Bez tego panie u mnie działa szybciej.

Po co w ogóle kwantyzować

Zacznijmy od podstaw, bo to jest pierwsze miejsce gdzie się miesza. Kwantyzacja modelu ma dwa cele – i prawie nigdy oba naraz:

  1. Zmieścić model w VRAM – wagi z fp16 (2 bajty/parametr) pakujemy do int8 (1 bajt) albo int4 (pół bajta) lub fp4 (na nowym RTX 5000). Model 12 mld parametrów schodzi z 24 GB do 6 GB. To jest główny powód, dla którego ktokolwiek to robi.
  2. Czasem przyspieszyć inference – i tu zaczyna się pole minowe. Bo „czasem” znaczy „tylko jeśli twoje GPU ma natywne tensor cores dla danego formatu”. A większość formatów których używają biblioteki kwantyzacji… nie ma.

Cała reszta artykułu to konsekwencja punktu drugiego. Jeśli zapamiętasz tylko jedno zdanie z tego tekstu, niech będzie to: kwantyzuj, jeśli musisz ze względu na VRAM. Nie kwantyzuj dla speedu, bo prawie zawsze będzie wolniej.

pic_full
Pełny FP16

Dlaczego niższe bity ≠ szybciej

Mechanika jest prosta, jak się ją raz zobaczy. GPU ma fizyczne, krzemowe instrukcje MatMul tylko dla wybranych formatów liczbowych. Reszta to software.

Architektura Natywne tensor cores
Ampere (RTX 30xx, A100) fp16, bf16, tf32, int8, int4
Ada Lovelace (RTX 40xx, w tym 4090 mobile) + fp8 (E4M3/E5M2)
Blackwell (RTX 50xx, B200) + fp4, mxfp8, mxfp4

Wszystko inne – nf4, int2, int1, int3, fp4 na Adzie konsumenckiej – nie ma natywnego MatMul w żadnym GPU dostępnym śmiertelnikowi. To znaczy, że kiedy biblioteka kwantyzacji „obiecuje” ci NF4, dzieje się tak naprawdę coś takiego:

  1. Wagi siedzą w VRAM spakowane (np. 8 wag NF4 wciśnięte w jeden int32). VRAM oszczędzony, tu działa.
  2. Tuż przed mnożeniem… rozpakowujemy je z powrotem do fp16. Custom CUDA kernel bitwise unpack.
  3. MatMul leci normalnie w fp16, na tych samych tensor coresach co fp16 baseline.

Czyli oszczędzamy VRAM (bo wagi spakowane), ale dokładamy 10-30% narzutu na dequantize w każdym kroku. Im niższe bity, tym więcej operacji bitowych przy unpacku. Im więcej operacji, tym wolniej.

Dla fp16 → int4 oszczędność jest 4×, dequantize stosunkowo tani – bywa, że wychodzimy mniej-więcej na zero. Dla fp16 → int2 albo int1 oszczędność jest 8×-16×, ale dequantize zaczyna być droższy niż samo mnożenie. Wynik: na 1-bitowych wagach inference potrafi być 3× wolniejsze niż fp16.

pic_quanto_int8
quanto int8

Tabela pomiarów – żeby nikt nie musiał wierzyć na słowo

SDXL 1024×1024, 25 kroków, RTX 4090 mobile (Ada, 16 GB VRAM), te same wagi base SDXL 1.0:

Preset Czas / obraz Względem fp16
fp16 / bf16 (baseline) 9 s 1.0×
bnb-int4 9 s 1.0× (int4 ma tensor cores!)
bnb-nf4 13 s 1.4×
torchao-int8 17 s 1.9×
torchao-fp8 17 s 1.9×
hqq-8bit 13 s 1.4×
hqq-4bit 18 s 2.0×
hqq-3bit 52 s 5.8× (!)
hqq-2bit 24 s 2.7×
hqq-1bit 26 s 2.9×
bnb-int8 32 s 3.6×

Spójrz na pierwsze dwie linie. bnb-int4 jest dokładnie tak szybkie jak fp16. Bo Ampere/Ada mają tensor cores int4 – wagi idą natywnie, bez dequantize-w-locie.

A teraz bnb-int8 – 3.6× wolniej. Czemu? Bo bnb-int8 to nie czysty INT8 weight-only – to mixed precision z dekompozycją outlierów (LLM.int8() Tima Dettmersa). Część wag idzie w INT8, część w fp16, są dwa osobne mnożenia, do tego cast bf16→fp16 między operacjami. Zaprojektowane było pod stabilność LLM-ów, nie pod speed. Działa świetnie do tego do czego było robione, ale dla diffusion to nie jest dobra opcja „domyślna”.

HQQ-3bit – 52 sekundy zamiast 9. Sześć razy wolniej niż baseline. Czyli żeby „oszczędzić VRAM” oddajesz 5× więcej czasu na każdy obrazek. Jak masz 1000 obrazków do wygenerowania to różnica robi się odczuwalna.

Wniosek z tabeli jest brutalny: nie patrz na liczbę bitów, patrz czy GPU ma natywny MatMul dla tego formatu. To jest pierwsza i jedyna heurystyka która działa.

Pięć backendów – kiedy co

W ekosystemie diffusers/transformers żyje pięć głównych bibliotek kwantyzacji. Każda z innym charakterem. Krótko, bo każda zasługuje na osobny artykuł, ale potrzebujesz mapy:

1. bitsandbytes (bnb)

Najszerszy zasięg, najprostsza ścieżka. Wspiera int8 i 4-bit (NF4, INT4, FP4-E2M1). OOTB w diffusers przez BitsAndBytesConfig.

  • bnb-int8 – mixed precision z dekompozycją outlierów. Stabilne, ale wolne (vide tabela).
  • bnb-nf4 – format zaprojektowany pod LLM (rozkład normalny wag). Stabilny, ale brak tensor cores → dequant.
  • bnb-int4 – klasyczny INT4 weight-only. Na Ampere/Ada idzie tensor cores int4, darmowy speed.
pic_torchao_int8
torchao int8

2. torchao

Oficjalna ścieżka PyTorch. Wymaga torchao≥0.7 + diffusers≥0.38. Pakiet, który nadrobi resztę ekosystemu w 2026/2027 – ale jeszcze trochę bolesny w użyciu, bo API się nadal zmienia.

  • torchao-int8 – Int8WeightOnlyConfig. Stabilny wszędzie.
  • torchao-int4 – Int4WeightOnlyConfig. Stabilny na denoiser, niestabilny na text encoder CLIP-G (wrócimy do tego).
  • torchao-fp8 – Float8WeightOnlyConfig. Niestabilny na text encoder. OK na UNet.
  • torchao-fp4 – Float8DynamicActivationInt4WeightConfig. Wymaga Blackwell. Na Adzie konsumenckiej nie ruszy.

Ważny gotcha: w diffusers 0.38 TorchAoConfig(quant_type=...) wymaga instancji AOBaseConfig, nie stringa. Starsze diffusers przyjmowały "int8wo". Jak ci coś nagle przestaje działać po pip upgrade – to prawdopodobnie tu.

3. quanto (optimum-quanto)

Backend HuggingFace. Wąsko wspiera precyzje (int2, int4, int8, float8), ale int2 to unikalna cecha – nigdzie indziej tego nie dostaniesz. Tylko nie spodziewaj się że to przyspieszy cokolwiek :)

pic_hqq_8bit
hqq 8bit

4. HQQ (Half-Quadratic Quantization)

Calibration-free, dowolna liczba bitów. 1, 2, 3, 4, 8 bit. Zastępuje nn.Linear przez HQQLinear w runtime’ie.

Zalety: brak datasetu kalibracyjnego (jak w GPTQ/AWQ), dowolny wybór bitów, działa na każdym GPU. Wady: pythonowa ścieżka forward() bez fused kernelu (wolne dla niskich bitów – vide HQQ-3bit z tabeli), 1/2/3 bit dają wizualne artefakty na SDXL, czas loadingu 30+s.

5. GGUF (community)

Format z llama.cpp, zaadaptowany przez społeczność do FLUX/SD3 (np. repo city96/FLUX.1-dev-gguf).

pic_bnb_int4
bnb int4
pic_hqq_4bit
hqq 4bit

Tabela stabilności: nie wszystko można kwantyzować po równo

Tu zaczyna się prawdziwa ciekawość – bo niektóre komponenty znoszą kwantyzację świetnie, a inne… rozsypują się w drobny mak. Empiryczne obserwacje na SDXL:

Komponent bnb-int8 bnb-int4/nf4 torchao-int8 torchao-fp8 torchao-int4 quanto-int8 hqq-4/8bit
UNet OK OK OK OK OK OK OK
text_encoder (CLIP-L) OK OK OK OK wątpliwe OK OK
text_encoder_2 (CLIP-G) OK OK OK NaN! NaN! OK OK
VAE unika się unika się unika się unika się unika się unika się unika się

Takie dwie ciakawostki.

  • Pierwsza – CLIP-G nienawidzi fp8 i int4 weight-only. Czemu? CLIP-G ma 1.4 mld parametrów i znaczną część dynamiki ulokowaną poza zakresem [-448, 448] (czyli zakres fp8 E4M3). Kwantyzujesz wagi → tracisz outliery → embeddingi wychodzą śmieciowe → UNet liczy szum → VAE wypluwa NaN → na wyjściu czarny obraz.

Czarny obraz to klasyczny symptom NaN w latents. Jak go zobaczysz, pierwsza myśl: „co zniszczyłem w text encoderze”. 90% przypadków tam jest.

  • Druga – VAE zostaje w fp16 zawsze. To jest mała kompesata (~80 MB), ale operacje (konwolucje, upsampling) są bardzo wrażliwe na noise. Nie ma sensu jej ruszać, bo oszczędność VRAM jest pomijalna, a degradacja jakości potrafi być wyraźna.
pic_hqq_2bit
hqq 2bit
pic_quantro_int2
quantro int2
pic_hqq_1bit
hqq 1bit

Czasy z profilera

sdf-xl-1.0:torchao-fp4   TextToImageGenerator:create_model  not finished  N/A           N/A            N/A           N/A                               1
sdf-xl-1.0:quanto-int8   TextToImageGenerator:create_model  9.67669 sec   9.67669 sec   9.67669 sec    9.67669 sec   4458246144                        1
sdf-xl-1.0:quanto-int8   TextToImageGenerator:generate      10.05025 sec  10.05025 sec  10.05025 sec   10.05025 sec  -12623872                         1
sdf-xl-1.0:quanto-int8   TextToImageGenerator:save_results  0.02003 sec   0.02003 sec   0.02003 sec    0.02003 sec   0                                 1
sdf-xl-1.0:torchao-int8  TextToImageGenerator:create_model  11.80200 sec  11.80200 sec  11.80200 sec   11.80200 sec  3877761024                        1
sdf-xl-1.0:torchao-int8  TextToImageGenerator:generate      13.60181 sec  13.60181 sec  13.60181 sec   13.60181 sec  10059776                          1
sdf-xl-1.0:torchao-int8  TextToImageGenerator:save_results  0.01174 sec   0.01174 sec   0.01174 sec    0.01174 sec   0                                 1
sdf-xl-1.0:hqq-8bit      TextToImageGenerator:create_model  29.19757 sec  29.19757 sec  29.19757 sec   29.19757 sec  4755091456                        1
sdf-xl-1.0:hqq-8bit      TextToImageGenerator:generate      16.60006 sec  16.60006 sec  16.60006 sec   16.60006 sec  4853760                           1
sdf-xl-1.0:hqq-8bit      TextToImageGenerator:save_results  0.01172 sec   0.01172 sec   0.01172 sec    0.01172 sec   0                                 1
sdf-xl-1.0:torchao-int4  TextToImageGenerator:create_model  not finished  N/A           N/A            N/A           N/A                               2
sdf-xl-1.0:hqq-4bit      TextToImageGenerator:create_model  35.28185 sec  35.28185 sec  35.28185 sec   35.28185 sec  1573851136                        1
sdf-xl-1.0:hqq-4bit      TextToImageGenerator:generate      28.32846 sec  28.32846 sec  28.32846 sec   28.32846 sec  22056960                          1
sdf-xl-1.0:hqq-4bit      TextToImageGenerator:save_results  0.01318 sec   0.01318 sec   0.01318 sec    0.01318 sec   0                                 1
sdf-xl-1.0:bnb-int4      TextToImageGenerator:create_model  17.52835 sec  17.52835 sec  17.52835 sec   17.52835 sec  1704247296                        1
sdf-xl-1.0:bnb-int4      TextToImageGenerator:generate      13.44075 sec  13.44075 sec  13.44075 sec   13.44075 sec  -14581760                         1
sdf-xl-1.0:bnb-int4      TextToImageGenerator:save_results  0.01033 sec   0.01033 sec   0.01033 sec    0.01033 sec   0                                 1
sdf-xl-1.0:quanto-int2   TextToImageGenerator:create_model  14.87508 sec  14.87508 sec  14.87508 sec   14.87508 sec  870027264                         1
sdf-xl-1.0:quanto-int2   TextToImageGenerator:generate      24.74862 sec  24.74862 sec  24.74862 sec   24.74862 sec  13602816                          1
sdf-xl-1.0:quanto-int2   TextToImageGenerator:save_results  0.01268 sec   0.01268 sec   0.01268 sec    0.01268 sec   0                                 1
sdf-xl-1.0:hqq-2bit      TextToImageGenerator:create_model  29.01123 sec  29.01123 sec  29.01123 sec   29.01123 sec  1251397632                        1
sdf-xl-1.0:hqq-2bit      TextToImageGenerator:generate      15.55375 sec  15.55375 sec  15.55375 sec   15.55375 sec  21401600                          1
sdf-xl-1.0:hqq-2bit      TextToImageGenerator:save_results  0.01248 sec   0.01248 sec   0.01248 sec    0.01248 sec   0                                 1
sdf-xl-1.0:hqq-1bit      TextToImageGenerator:create_model  31.83030 sec  31.83030 sec  31.83030 sec   31.83030 sec  558329856                         1
sdf-xl-1.0:hqq-1bit      TextToImageGenerator:generate      34.51453 sec  34.51453 sec  34.51453 sec   34.51453 sec  -3112960                          1
sdf-xl-1.0:hqq-1bit      TextToImageGenerator:save_results  0.01281 sec   0.01281 sec   0.01281 sec    0.01281 sec   0                                 1

Overall time for each index:

Index                    Total Time     Min          Max            Average         Call Count
-----------------------  -------------  -----------  -------------  ------------  ------------
sdf-xl-1.0:quanto-int8   19.74698 sec   0.02003 sec  10.05025 sec   6.58233 sec              3
sdf-xl-1.0:torchao-int8  25.41556 sec   0.01174 sec  13.60181 sec   8.47185 sec              3
sdf-xl-1.0:hqq-8bit      45.80934 sec   0.01172 sec  29.19757 sec   15.26978 sec             3
sdf-xl-1.0:hqq-4bit      63.62349 sec   0.01318 sec  35.28185 sec   21.20783 sec             3
sdf-xl-1.0:bnb-int4      30.97943 sec   0.01033 sec  17.52835 sec   10.32648 sec             3
sdf-xl-1.0:quanto-int2   39.63639 sec   0.01268 sec  24.74862 sec   13.21213 sec             3
sdf-xl-1.0:hqq-2bit      44.57746 sec   0.01248 sec  29.01123 sec   14.85915 sec             3
sdf-xl-1.0:hqq-1bit      66.35763 sec   0.01281 sec  34.51453 sec   22.11921 sec             3

Ps. Ciekawe jakby napisać swój własny kernel do kwantyzacji 1.5b :P w sumie powstaje model LLM 1.5b – narazie moja matematyka skończyła się na studiach :P


Następny wpis →

Kod, który zabija przeglądarkę – czyli spostrzeżenia po benchmarku małych modeli LLM

2026-06-04 · 7 min czytania