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:
- 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.
- 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.

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:
- Wagi siedzą w VRAM spakowane (np. 8 wag NF4 wciśnięte w jeden int32). VRAM oszczędzony, tu działa.
- Tuż przed mnożeniem… rozpakowujemy je z powrotem do fp16. Custom CUDA kernel bitwise unpack.
- 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.

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.

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 :)

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).


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.



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