Calcolatore VRAM per LLM — Posso eseguire questo LLM in locale?
Calcola quanta memoria GPU serve a un LLM locale con la tua quantizzazione e lunghezza del contesto, se entra nella tua GPU o nel tuo Mac e quanto sarà veloce.
8,03B parametri. Attenzione: 32 layer x 8 head KV x 128 dim.
Scuro: pesi · Blu: cache KV · Grigio: overhead. Qui GB significa GiB (1024³ byte), l'unità in cui si vende la memoria delle GPU.
| GPU / Mac | Utilizzabile | Esito | Velocità stim. |
|---|---|---|---|
| RTX 3060 12 GB 360 GB/s | 12 GB | Ci sta | ~39 tok/s |
| RTX 4060 Ti 16 GB 288 GB/s | 16 GB | Ci sta | ~31 tok/s |
| RTX 4070 Super 12 GB 504 GB/s | 12 GB | Ci sta | ~55 tok/s |
| RTX 4080 Super 16 GB 736 GB/s | 16 GB | Ci sta | ~80 tok/s |
| RTX 5080 16 GB 960 GB/s | 16 GB | Ci sta | ~104 tok/s |
| RTX 3090 24 GB 936 GB/s | 24 GB | Ci sta | ~102 tok/s |
| RTX 4090 24 GB 1008 GB/s | 24 GB | Ci sta | ~110 tok/s |
| RTX 5090 32 GB 1792 GB/s | 32 GB | Ci sta | ~195 tok/s |
| Radeon RX 7900 XTX 24 GB 960 GB/s | 24 GB | Ci sta | ~104 tok/s |
| RTX 6000 Ada 48 GB 960 GB/s | 48 GB | Ci sta | ~104 tok/s |
| A100 40 GB 1555 GB/s | 40 GB | Ci sta | ~169 tok/s |
| A100 80 GB (SXM) 2039 GB/s | 80 GB | Ci sta | ~222 tok/s |
| H100 80 GB (SXM) 3350 GB/s | 80 GB | Ci sta | ~364 tok/s |
| H200 141 GB 4800 GB/s | 141 GB | Ci sta | ~522 tok/s |
| Ryzen AI Max+ 395 (96 GB to GPU) 256 GB/s | 96 GB | Ci sta | ~28 tok/s |
| Mac M2/M3/M4, 16 GB 100 GB/s | 10.7 GB | Ci sta | ~11 tok/s |
| Mac M3/M4, 24 GB 120 GB/s | 16.1 GB | Ci sta | ~13 tok/s |
| Mac M4 Pro, 48 GB 273 GB/s | 36 GB | Ci sta | ~30 tok/s |
| Mac M4 Max, 64 GB 546 GB/s | 48 GB | Ci sta | ~59 tok/s |
| Mac M4 Max, 128 GB 546 GB/s | 96 GB | Ci sta | ~59 tok/s |
| Mac M2 Ultra, 192 GB 800 GB/s | 144 GB | Ci sta | ~87 tok/s |
| Mac M3 Ultra, 512 GB 819 GB/s | 384 GB | Ci sta | ~89 tok/s |
"Al limite" significa entro il 10% del limite: potrebbe caricarsi, ma un browser o un'altra app possono farlo sforare. La velocità è quella di generazione per un singolo utente, stimata come il 65% della banda di memoria diviso per i byte letti per token; l'elaborazione del prompt è più veloce e i valori reali variano in base al runtime. Per impostazione predefinita, Apple Silicon può assegnare alla GPU circa due terzi (fino a 36 GB) o tre quarti (oltre) della RAM.
Calcolato nel tuo browser. Nulla di ciò che inserisci viene inviato. Sfoglia tutti gli strumenti gratuiti.
Hai trovato un problema o qualcosa che potrebbe andare meglio? Leggiamo ogni messaggio e sistemiamo le cose in fretta.
Questo calcolatore VRAM per LLM risponde alla domanda "posso eseguire questo LLM in locale?" stimando la memoria che un modello richiede sulla tua GPU o sul tuo Mac: i pesi con la quantizzazione scelta, la cache KV per la lunghezza del contesto e l'overhead di runtime. Scegli un modello open diffuso o inserisci un numero di parametri, scegli una quantizzazione come Q4_K_M e guarda il totale accanto all'esito (ci sta, al limite, non ci sta) per le schede grafiche più comuni e i Mac con Apple Silicon, con una stima della velocità di generazione per ciascuno.
La maggior parte delle stime rapide moltiplica i parametri per i byte per peso e si ferma lì: un calcolo vicino al vero per prompt brevi e molto sbagliato per quelli lunghi. Un modello Llama 3.1 8B in Q4_K_M richiede circa 4,6 GB per i pesi, ma la sua cache KV cresce da 1 GB con un contesto di 8K a 16 GB con 128K. I preset qui includono la reale struttura di attention di ogni modello (grouped-query head, sliding window, latent attention di DeepSeek), così la cache KV viene dimensionata come la allocano davvero llama.cpp e vLLM. Le formule sono riportate qui sotto e i calcoli sono coperti da unit test sulle dimensioni reali dei file GGUF.
Come si usa
- Scegli un modello dall'elenco, oppure Personalizzato per inserire un numero di parametri (e, per una cache KV esatta, i valori di layer, KV head e head dim presi dal config.json del modello).
- Scegli la quantizzazione che pensi di scaricare. Q4_K_M è il punto di partenza abituale per i modelli GGUF in llama.cpp, Ollama e LM Studio.
- Imposta la lunghezza del contesto che userai davvero e il numero di sequenze parallele (1 per la chat personale, di più per un server).
- Leggi il totale e la ripartizione, poi l'esito per ogni GPU o Mac. Al limite significa entro il 10% della capacità.
- Se non ci sta, prova una quantizzazione più piccola, un contesto più breve, una cache KV Q8_0 o un modello con meno parametri.
Domande frequenti
Quanta VRAM serve per eseguire un modello da 8B?
Circa 6,5 GB per Llama 3.1 8B in Q4_K_M con un contesto di 8K: 4,6 GB di pesi, 1 GB di cache KV e meno di 1 GB di overhead. Entra in una GPU da 8 GB e comodamente in una RTX 3060 da 12 GB. In FP16 lo stesso modello richiede circa 17 GB, cioè una scheda da 24 GB. La lunghezza del contesto conta: con il contesto completo di 128K la sola cache KV occupa 16 GB.
Posso eseguire un modello da 70B su una GPU da 24 GB?
Non interamente in VRAM. Llama 3.3 70B in Q4_K_M richiede circa 40 GB per i pesi e circa 45 GB in totale con un contesto di 8K; anche Q2_K richiede circa 30 GB. Le opzioni sono due GPU da 24 GB, una scheda da 48 GB, un Mac con 64 GB o più di memoria unificata, oppure spostare parte del modello nella RAM di sistema, che funziona ma è parecchie volte più lento.
Che cos'è la cache KV e perché cresce con il contesto?
Durante la generazione il modello memorizza un vettore chiave e un vettore valore per ogni token precedente in ogni layer, così non deve ricalcolarli per ogni nuovo token. La sua dimensione è 2 x layer x KV head x dimensione della head x lunghezza del contesto x byte per valore. Per Llama 3.1 8B (32 layer, 8 KV head, head dim 128, FP16) fa 128 KB per token: 1 GB con 8K token e 16 GB con 128K. I modelli con grouped-query attention, layer a sliding window (Gemma) o latent attention (DeepSeek) ne richiedono molta meno.
Quale quantizzazione usare?
Q4_K_M è il compromesso standard: circa un terzo della dimensione FP16 con una piccola perdita di qualità per la maggior parte degli usi. Usa Q5_K_M o Q6_K se ci stanno, Q8_0 quando vuoi risultati praticamente identici all'originale ed evita Q3 e Q2 sui modelli sotto i 30B parametri circa, dove il calo di qualità diventa evidente. Un modello più grande in Q4 di solito batte un modello più piccolo in Q8 con lo stesso peso del file.
Per gli LLM in locale è meglio un Mac o una GPU NVIDIA?
Un Mac fa entrare modelli più grandi; una GPU NVIDIA esegue più velocemente quelli che ci stanno. Apple Silicon condivide un unico pool di memoria tra CPU e GPU, quindi un Mac da 128 GB può contenere un modello da 70B che nessuna scheda grafica consumer può ospitare, ma la sua banda di memoria (546 GB/s su un M4 Max) è circa la metà dei 1.008 GB/s di una RTX 4090, e la velocità di generazione cresce con la banda. Per impostazione predefinita macOS lascia usare alla GPU circa due terzi della RAM sui computer fino a 36 GB e circa tre quarti su quelli più grandi.
Quanto è precisa la stima dei token al secondo?
È un'indicazione di massima, di solito entro il 30% per la generazione con un solo utente. Generare ogni token significa leggere una volta dalla memoria i pesi attivi e la cache KV, quindi la velocità è circa la banda di memoria divisa per i byte per token; lo strumento presume che si raggiunga il 65% della banda di picco. L'elaborazione del prompt è limitata dal calcolo ed è molto più veloce, i modelli MoE aggiungono un overhead di routing, e runtime, driver e impostazioni spostano tutti i numeri reali.
Le formule usate da questo calcolatore
Memoria totale = pesi del modello + cache KV + overhead di runtime. Tutte le dimensioni sono in GiB (1.024³ byte), l'unità con cui viene venduta la memoria delle GPU: una RTX 4090 "da 24 GB" ha 24 GiB.
Pesi = parametri x bit per peso / 8. Per le k-quant GGUF i bit per peso sono valori effettivi misurati su file reali, perché ogni tipo di quantizzazione mescola precisioni diverse tra i tensori: Q8_0 8,5, Q6_K 6,57, Q5_K_M 5,70, Q4_K_M 4,89, IQ4_XS 4,43, Q3_K_M 4,00, Q2_K 3,17 (dai file GGUF di Llama 3.1 8B; i modelli più grandi risultano fino a circa il 5% più piccoli). AWQ e GPTQ usano pesi a 4 bit con una scala ogni 128 pesi (circa 4,16 bit) e mantengono embedding e layer di output a 16 bit; gpt-oss distribuisce i pesi degli esperti in MXFP4 (4,25 bit) con attention ed embedding in BF16.
Cache KV = 2 x layer x KV head x head dim x token x byte per valore x sequenze parallele. È per via della grouped-query attention che kv_heads (8 per Llama 3 70B) è molto più piccolo del numero di attention head (64). I layer a sliding window memorizzano al massimo la loro finestra (1.024 token su Gemma 3, 128 su metà dei layer di gpt-oss). DeepSeek V3 e R1 memorizzano un latente da 576 valori per layer per token invece di chiavi e valori completi. FP16 usa 2 byte per valore, una cache Q8_0 circa 1,06 e Q4_0 circa 0,56.
Overhead = 0,75 GiB + 3% dei pesi, per coprire il contesto CUDA o Metal e i buffer di calcolo. I runtime reali differiscono di qualche centinaio di megabyte. Velocità = banda di memoria x 0,65 / (byte dei pesi attivi + cache KV di una sequenza).
Dimensioni delle quantizzazioni in breve
Solo pesi, calcolati da questo strumento, per Llama 3.1 8B e Llama 3.3 70B:
• FP16 / BF16: 15,0 GB e 131,5 GB
• Q8_0: 7,9 GB e 69,9 GB
• Q6_K: 6,1 GB e 54,0 GB
• Q5_K_M: 5,3 GB e 46,8 GB
• Q4_K_M: 4,6 GB e 40,2 GB
• Q3_K_M: 3,7 GB e 32,9 GB
• Q2_K: 3,0 GB e 26,1 GB
Aggiungi la cache KV per il tuo contesto e circa 1 GB di overhead per ottenere ciò che la GPU deve contenere.
Modelli mixture-of-experts: la memoria di un modello grande, la velocità di uno piccolo
Un modello mixture-of-experts (MoE) come Qwen3 30B-A3B, Mixtral 8x7B, gpt-oss o DeepSeek R1 contiene molte sottoreti esperte ma ne usa solo poche per ogni token. Tutte devono stare in memoria, quindi la memoria dipende dal numero totale di parametri. La velocità dipende invece dai parametri attivi, perché per ogni token vengono letti solo quei pesi.
Ecco perché Qwen3 30B-A3B in Q4_K_M richiede circa 19 GB, la memoria di un modello denso da 30B, ma genera testo alla velocità di uno da 3B. Ed è anche il motivo per cui i modelli MoE sono adatti ai Mac e ad altri computer con tanta memoria più lenta: il vincolo è la capacità, meno la banda.
DeepSeek R1 con 671B parametri è il caso estremo: circa 380 GB in Q4_K_M, oltre le possibilità di qualsiasi singolo computer consumer, anche se per ogni token sono attivi solo 37B parametri.
Strumenti gratuiti correlati
- Calcolatore costi API LLM — Confronta il costo del tuo carico di lavoro su oltre 40 modelli, con caching, sconti batch, fasce per contesti lunghi e token di ragionamento. Prezzi con fonte e data.
- Contatore di token — Conta i token in modo esatto per i modelli OpenAI, stimali per Claude, Gemini e Llama, guarda il costo e osserva il testo diviso in token.
- Calcolatore ROI dell'IA — Stima quante ore e quanto denaro automatizzare un'attività ripetitiva potrebbe far risparmiare alla tua azienda ogni anno.