Metodologia di memoria e banda per LLM consapevole dell’architettura
VRAMLab modella la memoria di inferenza degli LLM a partire dalle dimensioni tensoriali fondamentali anziché da moltiplicatori euristici fissi, eseguendo ogni calcolo al 100% lato client su risorse statiche.
1. Quantizzazione dei pesi e bit effettivi per peso (bpw)
I formati quantizzati memorizzano fattori di scala per blocco e zero-point accanto ai pesi interi compatti. Un checkpoint GGUF Q4_K_M a 4 bit richiede in media 4.85 bit effettivi per parametro (non 4.00), mentre Q8_0 si attesta a 8.50 bpw. Nei modelli Mixture-of-Experts, tutti gli esperti instradati e condivisi restano residenti in memoria per evitare il paging dall’host a ogni token.
| Precisione / Formato | bpw effettivi | 32B Weights | 70B Weights | vLLM / Ollama / GGUF |
|---|---|---|---|---|
| FP16 / BF16 (16-bit Native) | 16.00 bpw | 61.09 GB | 131.50 GB | native · fp16 · F16 / BF16 |
| FP8 E4M3 (Hopper / Ada / Blackwell) | 8.50 bpw | 32.46 GB | 69.86 GB | fp8 · fp8 · FP8_E4M3 |
| INT8 SmoothQuant / bitsandbytes | 8.50 bpw | 32.46 GB | 69.86 GB | bitsandbytes · q8_0 · INT8 |
| GGUF Q8_0 (8.50 bpw) | 8.50 bpw | 32.46 GB | 69.86 GB | gguf · q8_0 · Q8_0 |
| GGUF Q6_K (6.56 bpw) | 6.56 bpw | 25.05 GB | 53.92 GB | gguf · q6_K · Q6_K |
| GGUF Q5_K_M (5.69 bpw) | 5.69 bpw | 21.73 GB | 46.77 GB | gguf · q5_K_M · Q5_K_M |
| GGUF Q4_K_M (4.85 bpw — Recommended) | 4.85 bpw | 18.52 GB | 39.86 GB | gguf · q4_K_M · Q4_K_M |
| AWQ / GPTQ INT4 (4.50 bpw) | 4.50 bpw | 17.18 GB | 36.99 GB | awq · q4_K_M · AWQ_4BIT |
| GGUF IQ4_XS (4.25 bpw Importance Matrix) | 4.25 bpw | 16.23 GB | 34.93 GB | gguf · iq4_XS · IQ4_XS |
| GGUF Q3_K_M (3.91 bpw) | 3.91 bpw | 14.93 GB | 32.14 GB | gguf · q3_K_M · Q3_K_M |
| GGUF Q2_K (3.35 bpw Extreme) | 3.35 bpw | 12.79 GB | 27.53 GB | gguf · q2_K · Q2_K |
2. Equazioni della KV cache specifiche per attenzione (MHA, GQA, MLA e SWA ibrida)
La Grouped-Query Attention standard alloca 2 × L × H_kv × d_head × S × B × bytes_kv lungo i livelli. La Multi-head Latent Attention di DeepSeek (MLA) comprime chiavi e valori in L × (d_kv_lora + d_qk_rope) × S × B × bytes_kv, riducendo di oltre il 90% la memoria sui contesti lunghi. I modelli ibridi a finestra scorrevole limitano i livelli di attenzione locale a min(S, window_size) facendo scalare linearmente con S quelli globali.
- Attenzione multi-testa (MHA) / Attenzione a query raggruppate (GQA)
- 2 × L × H_kv × d_head × S × B × bytes_kv
- Attenzione latente multi-testa (MLA)
- L × (kv_lora_rank + qk_rope_dim) × S × B × bytes_kv
- Finestra scorrevole ibrida (SWA)
- (L_global × S + L_local × min(S, W)) × 2 × H_kv × d_head × B × bytes_kv
- Miscela di esperti (MoE)
- Weights ∝ P_total · Decode tok/s ∝ BW / P_active
3. Memoria unificata Apple Silicon e limite superiore di banda in decodifica
Sui sistemi macOS con Apple Silicon, l’allocazione GPU wired predefinita si ferma intorno al 75% della RAM fisica unificata salvo modifica tramite sysctl iogpu.wired_limit_mb (modellata fino a un tetto sicuro dell’88% che tutela la stabilità del sistema operativo). La velocità di decodifica autoregressiva è limitata dalla banda effettiva della memoria esterna divisa per i byte dei parametri attivi più i byte attivi della KV cache letti ad ogni passo, verificata ogni 12 ore dalla pipeline automatizzata di VRAMLab.
| Acceleratore / Sistema | Memoria fisica | Default Usable | Tuned Ceiling | Banda di memoria |
|---|---|---|---|---|
| NVIDIA GeForce RTX 3090 (24 GB GDDR6X) | 24 GB | 22.1 GB (92%) | 23.0 GB (96%) | 936 GB/s |
| NVIDIA GeForce RTX 4090 (24 GB GDDR6X) | 24 GB | 22.1 GB (92%) | 23.0 GB (96%) | 1,008 GB/s |
| NVIDIA GeForce RTX 5090 (32 GB GDDR7) | 32 GB | 29.4 GB (92%) | 30.7 GB (96%) | 1,792 GB/s |
| Apple Silicon M-Series Max (64 GB Unified Memory) | 64 GB | 48.0 GB (75%) | 56.3 GB (88% sysctl) | 546 GB/s |
| Apple Mac Studio M4 Max (128 GB Unified Memory) | 128 GB | 96.0 GB (75%) | 112.6 GB (88% sysctl) | 546 GB/s |
| Apple Mac Studio M2/M3 Ultra (192 GB Unified Memory) | 192 GB | 144.0 GB (75%) | 169.0 GB (88% sysctl) | 800 GB/s |
| NVIDIA A100 SXM4 (80 GB HBM2e) | 80 GB | 73.6 GB (92%) | 76.8 GB (96%) | 2,039 GB/s |
| NVIDIA H100 SXM5 (80 GB HBM3) | 80 GB | 73.6 GB (92%) | 76.8 GB (96%) | 3,350 GB/s |
4. Workbench ingegneristici collegati di CodeAP Studio
Abbina la pianificazione della capacità su VRAMLab ai prezzi live di oltre 460 API LLM e alla modellazione dei rate limit 429 su DevToken, al monitoraggio delle deprecazioni su 7 ecosistemi su LLMEOL e alla compressione token da PDF/DOCX/HTML a Markdown su ToMarkdown.
Domande frequenti
In che modo DeepSeek MLA riduce la VRAM della KV cache rispetto alla GQA standard?
La Multi-head Latent Attention proietta chiavi e valori in un vettore latente condiviso a basso rango (come kv_lora_rank = 512 più qk_rope_head_dim = 64) invece di memorizzare tensori 2 × H_kv × head_dim per livello, abbattendo di oltre il 90% la memoria della KV cache sui contesti lunghi rispetto alla MHA non compressa.
Perché i modelli Mixture-of-Experts (MoE) richiedono molta VRAM ma decodificano velocemente?
Ogni esperto instradato deve restare residente nella memoria GPU o unificata per evitare colli di bottiglia su PCIe o SSD, quindi la VRAM scala con i parametri totali (es. 235B per Qwen3-235B-A22B). La velocità di decodifica in tok/s dipende invece dalla banda di memoria letta sui soli parametri attivi per token (22B), offrendo prestazioni simili a un modello denso da 32B.
Perché macOS va in OOM su Apple Silicon prima di utilizzare il 100% della RAM unificata?
macOS riserva parte della memoria unificata al kernel e al compositore grafico tramite iogpu.wired_limit_mb (~75% della RAM fisica per impostazione predefinita). I modelli compresi tra il 75% e l’88% della RAM richiedono di innalzare iogpu.wired_limit_mb con sysctl prima di avviare Ollama o llama.cpp.
Da dove provengono le dimensioni architetturali usate da VRAMLab?
La nostra pipeline automatizzata di verifica architetturale ogni 12 ore convalida i campi numerici delle configurazioni Transformer dai rilasci ufficiali open-weight e li compila in HTML statico, senza alcuna chiamata API a runtime né telemetria utente.