Szybka odpowiedź
O tym, jaki model AI uruchomisz lokalnie, decyduje pamięć GPU (VRAM), a o szybkości generowania jej przepustowość. Karta 16 GB (RTX 5060 Ti) wystarczy na modele 7-9B i asystenta dla jednej osoby. 24 GB z ECC (RTX PRO 4000 Blackwell) obsłuży RAG dla małego zespołu na modelu 8-14B w FP8 i pracę ciągłą w serwerze. 32 GB (RTX 5090) mieści modele do ok. 32B w FP4 i małe modele MoE, przy tej samej przepustowości co RTX PRO 6000. Modele ~70B, MoE ponad 100B i otwarte modele klasy frontier wymagają więcej pamięci: opisujemy je w Części 2.
Co zmieści się na którym GPU?
Tabela pokazuje stan na 7 września 2026 r. „Realnie” oznacza: wagi plus cache KV na sensowny kontekst, z ok. 10% zapasu. Obliczenia są w kolejnych sekcjach.
| Poziom | VRAM | Przepustowość pamięci | Co realnie się mieści | Typowe zastosowanie |
|---|---|---|---|---|
| RTX 5060 Ti 16 GB | 16 GB GDDR7 | 448 GB/s | gęste 7-9B w FP8 lub FP4, 14B tylko w FP4, gpt-oss-20b | asystent osobisty, nauka, prototypy, QLoRA modeli ~8B |
| RTX PRO 4000 Blackwell | 24 GB GDDR7 z ECC | 672 GB/s | gęste 7-14B w FP8, MoE 30B-A3B w FP4 z krótkim kontekstem, 24-32B w FP4 dla jednej osoby | RAG dla małego zespołu na modelu 8-14B, gęste serwery o niskim poborze mocy |
| RTX 5090 32 GB | 32 GB GDDR7 | 1792 GB/s | gęste 7-14B w BF16 lub FP8, 24-32B w FP4, MoE 30B-A3B w FP4 | mocny asystent osobisty, RAG dla kilku osób, LoRA modeli 7-8B |
W pimento uruchamiamy modele na NVIDIA Blackwell, ale ten tekst nie opisuje naszej konfiguracji. To ogólny przewodnik po rynku, oparty na specyfikacjach NVIDIA i kartach modeli na Hugging Face.
Jak policzyć, ile pamięci potrzebuje model?
Pamięć GPU dzielisz na trzy części: wagi modelu, cache KV (pamięć kontekstu) i narzut (kontekst CUDA, aktywacje, bufory silnika). Każdą da się policzyć albo oszacować przed zakupem sprzętu.
Wagi: parametry razy bajty na parametr
Pamięć wag ≈ liczba parametrów × bajty na parametr. Bajty zależą od precyzji:
- BF16/FP16: 2 bajty. Tak publikuje się większość modeli.
- FP8: 1 bajt. Część producentów publikuje wagi od razu w FP8 (np. Ministral 3, Mistral Small 4, DeepSeek-V3.1, GLM-5-FP8).
- FP4 (NVFP4, MXFP4): ok. 0,5-0,56 bajta. NVFP4 trzyma 4-bitowe wartości w blokach po 16, z jedną skalą FP8 na blok i jedną skalą FP32 na tensor (NVIDIA). To 4,5 bita, czyli ok. 0,56 bajta na parametr.
W praktyce pliki FP4 ważą trochę więcej, bo część warstw (np. embeddingi, uwaga) zostaje w wyższej precyzji. Sprawdziliśmy rozmiary oficjalnych plików na Hugging Face: gpt-oss-120b (117B parametrów) waży 65,2 GB, czyli ok. 0,56 bajta na parametr, Mistral Small 4 w NVFP4 (119B) 70,8 GB (0,59), Mistral Large 3 w NVFP4 (675B) 403 GB (0,60), a DeepSeek-V3.1 w NVFP4 od NVIDII (671B) 413 GB (0,62). Do szacunków przyjmujemy więc 0,6 bajta na parametr w FP4. Pliki FP8 trzymają się 1 bajta: Qwen3-235B-A22B-Instruct-2507-FP8 waży 236 GB.
| Model | Parametry | BF16 | FP8 | FP4 (~0,6 B/param) |
|---|---|---|---|---|
| Qwen3-8B | 8,2B | 16,4 GB | 8,2 GB | ~4,9 GB |
| Qwen3-14B | 14,8B | 29,6 GB | 14,8 GB | ~8,9 GB |
| Qwen3-32B | 32,8B | 65,6 GB | 32,8 GB | ~19,7 GB |
| Llama 3.3 70B | 70B (70,6B wg metadanych HF) | ~141 GB | ~71 GB | ~42 GB |
| Qwen3-30B-A3B-Instruct-2507 | 30,5B, 3,3B aktywnych | 61 GB | 30,5 GB | ~18 GB |
| gpt-oss-120b | 117B, 5,1B aktywnych | nie publikowany | nie publikowany | 65,2 GB (oficjalny MXFP4) |
| Qwen3-235B-A22B-Instruct-2507 | 235B, 22B aktywnych | 470 GB | 236 GB (oficjalny FP8) | ~141 GB |
| DeepSeek-V3.1 | 671B, 37B aktywnych | ~1,34 TB | 689 GB (oficjalny) | 413 GB (NVFP4 od NVIDII) |
FP8 jest zwykle bezpiecznym wyborem jakościowym. FP4 ma natywne wsparcie w rdzeniach Tensor wszystkich kart Blackwell z tej serii (NVIDIA RTX Blackwell, NVIDIA Blackwell Ultra), a coraz więcej producentów trenuje modele od razu z myślą o 4 bitach: gpt-oss wydano w MXFP4, Kimi K2.6 w natywnym INT4, a Kimi K3 w MXFP4 z treningiem świadomym kwantyzacji. Przy modelach kwantyzowanych po fakcie jakość w FP4 trzeba sprawdzić na własnym zestawie testowym.
Cache KV: przykład z config.json Qwen3-32B
Model przy generowaniu zapamiętuje dla każdego tokenu kontekstu klucze i wartości (K i V) z każdej warstwy. To cache KV. Wzór:
KV na token = 2 (K i V) × liczba warstw × liczba głów KV × wymiar głowy × bajty na wartość.
Weźmy config.json Qwen3-32B: num_hidden_layers: 64, num_attention_heads: 64, num_key_value_heads: 8, head_dim: 128. Model używa GQA (grouped-query attention): 64 głowy zapytań dzielą 8 głów KV. Liczymy w BF16:
- 2 × 64 × 8 × 128 × 2 bajty = 262 144 bajtów, czyli 256 KiB (ok. 0,26 MB) na token.
- Kontekst 32 768 tokenów: ok. 8,6 GB. Kontekst 128 tys. tokenów: ok. 34 GB.
- Bez GQA (64 głowy KV zamiast 8) byłoby to 2 MiB na token, czyli ok. 69 GB na 32 tys. tokenów. GQA zmniejsza cache ośmiokrotnie.
- Cache w FP8 zajmuje połowę, co silniki takie jak vLLM obsługują wprost (vLLM).
Ten sam wzór (wartości z config.json, nasze obliczenia, BF16) daje dla innych modeli:
| Model | Warstwy, głowy KV, wymiar głowy | KV na token | 32 tys. tokenów |
|---|---|---|---|
| Qwen3-8B | 36, 8, 128 | ~0,15 MB | ~4,8 GB |
| Qwen3-14B | 40, 8, 128 | ~0,16 MB | ~5,4 GB |
| Llama 3.3 70B | 80, 8, 128 | ~0,33 MB | ~10,7 GB |
| Qwen3-30B-A3B | 48, 4, 128 | ~0,10 MB | ~3,2 GB |
| Qwen3-235B-A22B | 94, 4, 128 | ~0,19 MB | ~6,3 GB |
| gpt-oss-120b | 18 warstw z pełną uwagą, 8, 64 | ~0,04 MB | ~1,2 GB |
Nowsze architektury zmniejszają cache jeszcze bardziej. gpt-oss przeplata pełną uwagę z oknem przesuwnym o długości 128 tokenów, więc cache rośnie tylko w połowie warstw. Gemma 4 ma 50 z 60 warstw z oknem 1024 tokenów, Qwen3.8-27B ma pełną uwagę w 16 z 64 warstw, a DeepSeek, Kimi K2 i GLM-5 kompresują cache do wspólnego wektora (MLA): dla Kimi K2 to ok. 0,07 MB na token. Dlatego wzór liczysz zawsze z config.json konkretnego modelu.
Reguła kciuka: kontekst i liczba użytkowników
- Pamięć użyteczna ≈ 90% VRAM. Resztę zabiera kontekst CUDA, aktywacje i bufory. vLLM domyślnie bierze 92% pamięci GPU (vLLM). Nasze 10% to przybliżenie, nie pomiar.
- Pamięć na cache = pamięć użyteczna minus wagi.
- Liczba tokenów w cache = pamięć na cache ÷ KV na token.
- Współbieżność ≈ liczba tokenów ÷ średni kontekst na rozmowę.
Przykład: Qwen3-32B w FP4 na RTX 5090. 32 GB × 0,9 = 28,8 GB. Minus ~19,7 GB wag zostaje ~9 GB, czyli ~35 tys. tokenów w BF16 albo ~70 tys. w FP8. To jedna osoba z kontekstem 32 tys. albo cztery z kontekstem 16 tys. przy cache w FP8. Agent, który wczytuje duże repozytorium albo długie dokumenty, zje cały ten budżet sam.
MoE: pamięć liczysz od wszystkich parametrów, szybkość od aktywnych
Model MoE (mixture of experts) dla każdego tokenu wybiera kilku ekspertów z wielu. Qwen3-30B-A3B ma 128 ekspertów, z których 8 pracuje przy każdym tokenie. Router może wybrać dowolnego eksperta, więc wszystkie wagi muszą być w VRAM: 30,5B parametrów zajmuje tyle pamięci co gęsty model 30B. Ale przy każdym tokenie czytane jest tylko ok. 3,3B parametrów, więc model generuje w tempie modelu ~3B. Dlatego MoE to najlepszy sposób na dużą jakość przy dużej szybkości, o ile masz pamięć na całość.
Można przenieść część ekspertów do RAM komputera (robią to np. llama.cpp i podobne narzędzia). Wtedy model działa, ale każdy token czyta część wag przez PCIe z pamięci systemowej, więc generowanie zwalnia kilkukrotnie lub bardziej. To dobre do eksperymentów, słabe do obsługi wielu osób.
Dlaczego o szybkości decyduje przepustowość pamięci?
Przy generowaniu każdego kolejnego tokenu GPU musi przeczytać z pamięci wszystkie aktywne wagi. Obliczeń jest przy tym mało, więc etap dekodowania jest ograniczony przepustowością pamięci, nie mocą obliczeniową (NVIDIA). Stąd prosty sufit dla jednej rozmowy:
Maksymalna liczba tokenów na sekundę ≈ przepustowość pamięci ÷ bajty aktywnych wag.
- Qwen3-32B w FP4 (~19,7 GB) na RTX 5090 (1792 GB/s): sufit ~90 tokenów/s.
- Ten sam model na RTX 5060 Ti (448 GB/s), gdyby się zmieścił: ~23 tokeny/s.
- Llama 3.3 70B w FP8 (~71 GB) na RTX PRO 6000 (1792 GB/s): ~25 tokenów/s. Na B300 (8 TB/s): ~113 tokenów/s.
To górne granice. Realne wyniki są niższe, bo dochodzi odczyt cache KV i narzuty silnika. Dwa wnioski są jednak pewne. Po pierwsze, „AI TOPS” z ulotki (np. 3352 dla RTX 5090, liczone w FP4 z rzadkością) mówią o mocy obliczeniowej, która ma znaczenie przy przetwarzaniu promptu i przy wielu równoległych rozmowach, a nie o tempie odpowiedzi dla jednej osoby. Po drugie, gdy obsługujesz wielu użytkowników naraz, jeden odczyt wag służy całej grupie zapytań (batching), więc łączna przepustowość rośnie z liczbą rozmów. Warunek: musi zostać pamięć na ich cache KV.
Jakie parametry mają te GPU?
Wszystkie dane pochodzą ze stron produktowych, kart katalogowych i whitepaperów NVIDIA. Nie podajemy cen: strony NVIDIA ich nie podają, a ceny sklepowe zmieniają się co tydzień.
| GPU | VRAM | Przepustowość | FP4 / FP8 | Połączenie między GPU | Forma i moc |
|---|---|---|---|---|---|
| RTX 5060 Ti 16 GB | 16 GB GDDR7, 128 bit | 448 GB/s | tak / tak (rdzenie Tensor 5. generacji), 759 AI TOPS | tylko PCIe 5.0, NVLink: nie | karta desktopowa, 180 W, zasilacz od 600 W |
| RTX PRO 4000 Blackwell | 24 GB GDDR7 z ECC | 672 GB/s | tak / tak, 1290 TOPS FP4 z rzadkością | PCIe 5.0, NVIDIA nie wymienia NVLink | jedno gniazdo, 145 W |
| RTX 5090 | 32 GB GDDR7, 512 bit | 1792 GB/s | tak / tak, 3352 AI TOPS | tylko PCIe 5.0, NVLink: nie | karta desktopowa, 575 W, zasilacz od 1000 W |
„AI TOPS” kart RTX to FP4 z rzadkością (sparsity), czyli wartość teoretyczna. W kartach GeForce NVIDIA podaje FP4 jako cechę rdzeni Tensor, a whitepaper RTX Blackwell potwierdza obsługę FP8 i FP4 w rdzeniach Tensor kart konsumenckich i profesjonalnych.
RTX 5060 Ti 16 GB: na co wystarczy najtańszy poziom?
16 GB i 448 GB/s to poziom osobistego asystenta i nauki. Pamięć użyteczna to ok. 14,4 GB.
| Klasa modelu | Czy się mieści | Precyzja | Realny kontekst i współbieżność |
|---|---|---|---|
| gęsty 7-9B (Qwen3-8B, Ministral 3 8B) | tak | FP8 (8,2 GB) lub FP4 (~4,9 GB) | FP8: ~42 tys. tokenów w cache BF16, ~84 tys. w FP8. Jedna-dwie osoby z kontekstem 16-32 tys. |
| gęsty 14B (Qwen3-14B, Ministral 3 14B) | tak, ciasno | tylko FP4 (~8,9 GB) | ~34 tys. tokenów w BF16, ~67 tys. w FP8. Jedna osoba |
| gęsty 24-32B | nie | FP4 to ~15-20 GB samych wag | tylko z przenoszeniem warstw do RAM, kilka tokenów na sekundę |
| MoE ~30B-A3B | częściowo | gpt-oss-20b (21B, 3,6B aktywnych) mieści się w 16 GB według OpenAI; Qwen3-30B-A3B w FP4 (~18 GB) nie | gpt-oss-20b: krótki kontekst, jedna osoba; Qwen3-30B-A3B tylko z ekspertami w RAM |
| gęsty ~70B, MoE ~100-120B i ~235B, frontier 0,7-1T+ | nie |
Co realnie zrobisz:
- Asystent osobisty: tak. Model 8B w FP8 generuje z sufitem ~55 tokenów/s, w FP4 ~90, czyli szybciej, niż się czyta.
- RAG dla zespołu: tylko jako prototyp dla 1-2 osób. Dokumenty wrzucane do kontekstu szybko zjadają 40-80 tys. tokenów cache.
- Backend agentów dla firmy: nie. Agenci potrzebują długiego kontekstu i równoległych wywołań.
- LoRA małych modeli: QLoRA modelu ~8B tak (baza w 4 bitach zajmuje ~5 GB). LoRA na bazie BF16 nie, bo same wagi 8B to 16,4 GB.
- Wielu użytkowników: nie.
- Dwie karty: brak NVLink, więc łączysz je przez PCIe. 2 × 16 GB to wciąż mniej niż jedna karta 32 GB, bo część pamięci każdej karty idzie na narzut.
RTX PRO 4000 Blackwell 24 GB: dla kogo karta profesjonalna z niższej półki?
24 GB z ECC, 672 GB/s, 145 W, jedno gniazdo. Przepustowość jest niższa niż w RTX 5090, ale karta jest wąska, chłodna i ma pamięć z korekcją błędów, więc pasuje do serwerów i stacji roboczych pracujących całą dobę. Pamięć użyteczna to ok. 21,6 GB.
| Klasa modelu | Czy się mieści | Precyzja | Realny kontekst i współbieżność |
|---|---|---|---|
| gęsty 7-9B | tak | FP8 (8,2 GB), BF16 ciasno | FP8: ~91 tys. tokenów w BF16, ~182 tys. w FP8. Kilka osób |
| gęsty 14B | tak | FP8 (14,8 GB) lub FP4 | FP8: ~42 tys. tokenów, FP4: ~78 tys. (cache BF16). 2-4 osoby |
| gęsty 24-32B | ledwo | FP4 (~19,7 GB dla Qwen3-32B) | ~7 tys. tokenów w BF16, ~15 tys. w FP8. Jedna osoba, krótki kontekst. Mniejsze modele 24B (np. Mistral Small 3.2) dają więcej zapasu |
| MoE ~30B-A3B | tak, ciasno | FP4 (~18 GB) | ~34 tys. tokenów w BF16, ~67 tys. w FP8. gpt-oss-20b (13,8 GB) mieści się z zapasem |
| gęsty ~70B, MoE ~100-120B i ~235B, frontier 0,7-1T+ | nie |
Co realnie zrobisz:
- Asystent osobisty: tak, z modelem 8-14B.
- RAG dla zespołu: tak, dla małego zespołu na modelu 8-14B w FP8. Sufit generowania dla 14B w FP8 to ~45 tokenów/s na rozmowę.
- Backend agentów: dla prostych agentów na modelu 8-14B.
- LoRA: QLoRA do ~14B wygodnie, ~24B ciasno. LoRA na bazie BF16 dla ~8B przy krótkich sekwencjach.
- Wielu użytkowników: kilku na modelu 8B.
- Kilka kart: niski pobór i jedno gniazdo ułatwiają montaż kilku kart w jednej obudowie, ale łączy je tylko PCIe. Ile kart zmieści konkretna stacja, zależy od producenta komputera.
RTX 5090 32 GB: ile da się wycisnąć z najmocniejszej karty konsumenckiej?
32 GB i 1792 GB/s: ta sama przepustowość co RTX PRO 6000, ale jedna trzecia pamięci. 575 W i zasilacz od 1000 W. Pamięć użyteczna to ok. 28,8 GB.
| Klasa modelu | Czy się mieści | Precyzja | Realny kontekst i współbieżność |
|---|---|---|---|
| gęsty 7-9B | tak | BF16 (16,4 GB) lub FP8 | FP8: ~140 tys. tokenów w BF16, ~280 tys. w FP8. Kilka-kilkanaście rozmów |
| gęsty 14B | tak | FP8 (14,8 GB) | ~85 tys. tokenów w BF16, ~170 tys. w FP8 |
| gęsty 24-32B (Qwen3-32B, Gemma 4 31B, Qwen3.8-27B) | tak | FP4 (~18-20 GB) | ~35 tys. tokenów w BF16, ~70 tys. w FP8. 1-4 osoby |
| gęsty ~70B | nie na jednej karcie | FP4 to ~42 GB | na dwóch kartach (64 GB) w FP4, przez PCIe |
| MoE ~30B-A3B (Qwen3-30B-A3B, Qwen3.6-35B-A3B, Gemma 4 26B A4B) | tak | FP4 (~18 GB dla Qwen3-30B-A3B) | ~107 tys. tokenów w BF16, ~214 tys. w FP8, bo cache tego modelu jest mały (~0,1 MB na token) |
| MoE ~100-120B | nie | gpt-oss-120b to 65,2 GB | tylko z ekspertami w RAM |
| MoE ~235B, frontier 0,7-1T+ | nie |
Co realnie zrobisz:
- Asystent osobisty: tak, z najlepszymi modelami 27-32B w FP4. Sufit generowania ~90 tokenów/s.
- RAG dla zespołu: dla kilku osób jednocześnie. Najlepiej z modelem MoE 30B-A3B, który ma mały cache i generuje w tempie modelu 3B.
- Backend agentów: na próbę lub dla małego zespołu. Karta konsumencka nie ma ECC ani gwarancji pracy ciągłej w serwerowni.
- LoRA: na bazie BF16 dla 7-8B, QLoRA do ~32B przy krótkich sekwencjach. OpenAI pisze, że gpt-oss-20b da się dostroić na sprzęcie konsumenckim.
- Wielu użytkowników: kilkunastu na modelu 8B, kilku na 32B.
- Dwie karty RTX 5090: 64 GB pozwala uruchomić 70B w FP4 z ~15 GB na cache. NVIDIA podaje w specyfikacji, że NVLink nie jest obsługiwany, więc karty komunikują się przez PCIe (szczegóły niżej).
Kilka kart: dlaczego PCIe to nie NVLink?
Gdy model nie mieści się na jednym GPU, dzielisz go między kilka. Dwa podstawowe sposoby:
- Tensor parallelism (TP): każda warstwa jest podzielona między GPU, które po każdej warstwie wymieniają wyniki. Przy każdym tokenie to dziesiątki synchronizacji, więc TP wymaga bardzo szybkiego połączenia.
- Pipeline parallelism (PP): każde GPU dostaje kolejne warstwy, a wyniki przechodzą dalej tylko na granicy. Komunikacji jest mniej, ale pojedyncze zapytanie nie przyspiesza.
Różnica w łączach jest duża. PCIe 5.0 x16 daje 128 GB/s (NVIDIA, H100), a NVLink 5 w B300 1,8 TB/s na GPU, czyli ok. 14 razy więcej. Dokumentacja vLLM zaleca TP, gdy model mieści się w jednym węźle, a dla GPU bez NVLink (podaje przykład L40S) zaleca pipeline parallelism zamiast tensor parallelism (vLLM).
Co z tego wynika dla kart z tej części:
- RTX 5060 Ti i RTX 5090: NVIDIA podaje w specyfikacji „NVLink: No”. Dwie karty działają przez PCIe. To wystarczy, żeby zmieścić większy model, ale nie daje liniowego przyspieszenia.
- RTX PRO 4000: NVIDIA nie wymienia NVLink w specyfikacji. Skalowanie idzie przez PCIe.
NVLink pojawia się dopiero w GPU klasy centrum danych, takich jak B300 w systemach HGX/DGX. Opisujemy je w Części 2.
Ile pamięci potrzebuje fine-tuning?
Trzy metody, trzy różne rachunki:
- QLoRA: baza zamrożona w 4 bitach, trenujesz tylko małe adaptery. Autorzy dostroili tak model 65B na jednym GPU 48 GB (Dettmers i in., 2023).
- LoRA: baza zamrożona w BF16 (2 bajty na parametr) plus adaptery. LoRA zmniejsza liczbę trenowanych parametrów nawet 10 000 razy, a zapotrzebowanie na pamięć GPU ok. 3 razy w porównaniu z pełnym fine-tuningiem (Hu i in., 2021).
- Pełny fine-tuning: z Adamem w mieszanej precyzji to 16 bajtów na parametr (wagi i gradienty w 16 bitach plus 12 bajtów stanu optymalizatora), bez aktywacji (Rajbhandari i in., ZeRO).
| Poziom | QLoRA | LoRA (baza BF16) | Pełny fine-tuning |
|---|---|---|---|
| RTX 5060 Ti 16 GB | do ~8B | nie | nie |
| RTX PRO 4000 24 GB | do ~14B, ~24B ciasno | ~7-8B, krótkie sekwencje | rząd 1B |
| RTX 5090 32 GB | do ~32B, krótkie sekwencje | ~7-8B | rząd 1B |
To szacunki z wzorów, zaokrąglone w dół, bo aktywacje rosną z długością sekwencji i rozmiarem batcha. Gradient checkpointing, optymalizatory 8-bitowe i przenoszenie stanu optymalizatora do RAM przesuwają te granice w górę kosztem czasu.
Trening od zera to nie zadanie dla tego poziomu: ile trwałby nawet na węźle 8×B300, liczymy w Części 2.
Jak wybrać kartę od 16 do 32 GB?
Zacznij od zadania, nie od karty. Odpowiedz na trzy pytania: jakiej jakości modelu potrzebujesz, ile osób będzie z niego korzystać naraz i jak długi kontekst przetwarzasz.
| Twoja sytuacja | Rozsądny poziom |
|---|---|
| Uczysz się, prototypujesz, potrzebujesz prywatnego asystenta | RTX 5060 Ti 16 GB z modelem 8B, gpt-oss-20b |
| Mocny asystent osobisty, programowanie z modelem 27-32B | RTX 5090 32 GB |
| RAG dla małego zespołu, praca ciągła, serwer o niskim poborze | RTX PRO 4000 Blackwell (jedna lub kilka kart) |
| RAG i agenci dla firmy, dziesiątki użytkowników, modele 70B i większe | RTX PRO 6000, B300 lub 8×B300, czyli Część 2 |
Trzy praktyczne zasady:
- Licz z config.json, nie z nazwy modelu. Dwa modele „30B” mogą mieć cache KV różniący się kilkukrotnie, zależnie od GQA, MLA i okien uwagi.
- Zostaw pamięć na kontekst. Model, który „mieści się” na karcie, ale zostawia 2 GB na cache, obsłuży jedną krótką rozmowę.
- Do szybkości patrz na przepustowość pamięci i parametry aktywne. Do pojemności patrz na VRAM i wszystkie parametry.
Jak projektujemy AI na własnej infrastrukturze, od doboru GPU po serwowanie modeli, pokazujemy na stronie Infrastruktura AI. Kiedy w ogóle warto przejść z API na własny model, opisujemy w artykule budować czy kupić AI.
Część 2: RTX PRO 6000, B300 i klaster 8×B300 → Co mieści się na 96 GB, 288 GB i 2,1 TB, gdzie zaczyna się NVLink i ile trwałby trening od zera na jednym węźle.
Źródła
Specyfikacje GPU:
- NVIDIA: GeForce RTX 5060 Family
- NVIDIA: GeForce RTX 5090
- NVIDIA: GeForce graphics cards, compare specs
- NVIDIA: RTX Blackwell GPU Architecture (whitepaper)
- NVIDIA: RTX Blackwell PRO GPU Architecture (whitepaper)
- NVIDIA: RTX PRO 4000 Blackwell
- NVIDIA: RTX PRO 6000 Blackwell Workstation Edition
- NVIDIA: Inside NVIDIA Blackwell Ultra
- NVIDIA: H100 (przepustowość PCIe Gen5)
Karty modeli i konfiguracje:
- Qwen/Qwen3-8B
- Qwen/Qwen3-14B
- Qwen/Qwen3-32B i config.json
- Qwen/Qwen3.8-27B
- Qwen/Qwen3-30B-A3B-Instruct-2507
- Qwen/Qwen3.6-35B-A3B
- Qwen/Qwen3-235B-A22B-Instruct-2507 i wersja FP8
- mistralai/Ministral-3-8B-Instruct-2512
- mistralai/Ministral-3-14B-Instruct-2512
- mistralai/Mistral-Small-3.2-24B-Instruct-2506
- mistralai/Mistral-Small-4-119B-2603 i wersja NVFP4
- mistralai/Mistral-Large-3-675B-Instruct-2512 i wersja NVFP4
- google/gemma-4-31B-it
- google/gemma-4-26B-A4B-it
- meta-llama/Llama-3.3-70B-Instruct
- openai/gpt-oss-20b
- openai/gpt-oss-120b
- zai-org/GLM-5 i wersja FP8
- deepseek-ai/DeepSeek-V3.1 i NVFP4 od NVIDII
- moonshotai/Kimi-K2-Instruct
- moonshotai/Kimi-K2.6
- moonshotai/Kimi-K3
Metoda, serwowanie i trening:
- NVIDIA: Mastering LLM Techniques, Inference Optimization
- vLLM: Parallelism and Scaling
- vLLM: Quantized KV Cache
- vLLM: Engine Arguments
- Dettmers i in.: QLoRA, Efficient Finetuning of Quantized LLMs (2023)
- Hu i in.: LoRA, Low-Rank Adaptation of Large Language Models (2021)
- Rajbhandari i in.: ZeRO, Memory Optimizations Toward Training Trillion Parameter Models (2019)
