Guida Dimensionamento · 9 min di lettura

# Quanta VRAM serve davvero a un modello.

Sono due numeri a deciderlo: i pesi, che sono fissi, e la cache KV, che cresce con la quantità di contesto servito. Quasi ogni risposta sbagliata nasce dallo stimare il secondo a partire dal primo.

La risposta breve

- **Weights:** Parametri in miliardi × byte per parametro. 70B a 4 bit sono **35 GB**.
- **Cache KV:** 2 × livelli × teste KV × dimensione della testa × byte, per token. Non ha nulla a che vedere con il numero di parametri.
- **Overhead:** Aggiunga circa il **15%** per attivazioni, contesto CUDA e frammentazione dell’allocatore.
- **La trappola:** Quantizzare i pesi a 4 bit **non** quantizza la cache. Resta FP16 in ogni stack comune.

## La formula

Non esiste qui una regola empirica che sopravviva al confronto con un secondo modello. L’intero calcolo è di tre righe, e vale la pena farle piuttosto che fidarsi di un moltiplicatore.

VRAM totale, in GB

```
# 1. Weights
weights_gb   = parameters_in_billions × bytes_per_parameter

# 2. KV cache, per token — then multiplied by the context you serve
bytes_per_tok = 2 × layers × kv_heads × head_dim × cache_bytes
cache_gb      = bytes_per_tok × context_tokens × batch / 1024³

# 3. Everything else
total_gb      = (weights_gb + cache_gb) × 1.15
```

Il `2` c’è perché ci sono due tensori per token, K e V. `bytes_per_parameter` è 2 per BF16, 1 per FP8, 0.5 per 4-bit. `cache_bytes` è un numero *separato*, e questa separazione è la fonte più comune in assoluto di una risposta sbagliata — consulti [qui sotto](https://gpuserver.io/it/guides/vram-sizing#wrong).

## Pesi

La metà facile. È esattamente lineare nel numero di parametri, e l’unica decisione è la precisione.

**Memoria dei pesi per precisione, per una selezione di dimensioni di modello**

| Modello | BF16 / FP16 | FP8 | 4-bit (AWQ, GPTQ) |
|---|---|---|---|
| Llama 3.1 8B 8B di parametri | 16.0 GB | 8.0 GB | 4.0 GB |
| Qwen 3 32B 32B di parametri | 64.0 GB | 32.0 GB | 16.0 GB |
| Llama 3.3 70B 70B di parametri | 140.0 GB | 70.0 GB | 35.0 GB |
| Llama 3.1 405B 405B di parametri | 810.0 GB | 405.0 GB | 202.5 GB |

La quantizzazione a 4 bit ha un costo in qualità, e quanto dipende dal modello molto più che dal metodo. È il compromesso giusto quando fa la differenza tra una scheda e quattro; è un compromesso scadente quando si è già ampiamente nei margini.

## La cache KV

La metà difficile, quella che decide se una macchina è adeguata a 4k e inutilizzabile a 128k. Dipende dai livelli e dalle teste KV — *non* da quanto è grande il modello.

**Due modelli di dimensioni molto diverse, a confronto.** Llama 3.3 70B ha 80 livelli e 8 teste KV, quindi 320 KB per token. Gemma 3 27B — un terzo dei parametri — ha 62 livelli e 16 teste KV, quindi 496 KB per token, cioè 1.6× *di più*. Qualsiasi stima ricavata dal numero di parametri arriva alla conclusione opposta.

**Dimensione della cache KV per modello e lunghezza del contesto, a precisione cache FP16, una richiesta**

| Modello | Per token | contesto di 4k | contesto di 8k | contesto di 32k | contesto di 128k |
|---|---|---|---|---|---|
| Llama 3.1 8B 32 livelli · 8 teste KV | 128 KB | 0.5 GB | 1.0 GB | 4.0 GB | 16.0 GB |
| Gemma 3 27B 62 livelli · 16 teste KV | 496 KB | 1.9 GB | 3.9 GB | 15.5 GB | 62.0 GB |
| Llama 3.3 70B 80 livelli · 8 teste KV | 320 KB | 1.3 GB | 2.5 GB | 10.0 GB | 40.0 GB |
| DeepSeek V3 671B-A37B (MoE) Attenzione latente | 70 KB | 0.3 GB | 0.5 GB | 2.2 GB | 8.8 GB |
| Llama 3.1 405B 126 livelli · 8 teste KV | 504 KB | 2.0 GB | 3.9 GB | 15.8 GB | 63.0 GB |

Legga prima l’ultima colonna, poi la prima. A un contesto di 4k la cache è un errore di arrotondamento trascurabile per ogni modello qui presente; a 128k è più grande dei pesi di un modello da 70B a 4 bit. DeepSeek V3 è l’eccezione perché la sua attenzione latente comprime la cache per progettazione — motivo per cui resta utilizzabile a contesti lunghi pur essendo il modello più grande dell’elenco.

## Dove le stime sbagliano

**Far scalare la cache in base al numero di parametri.** L’errore più comune, ed è quello mostrato sopra. Un modello da 27B può richiedere più cache di uno da 70B.

**Supporre che pesi a 4 bit significhino una cache a 4 bit.** Non è così. AWQ e GPTQ quantizzano solo i pesi; la cache resta FP16 a meno che non si attivi esplicitamente la cache KV FP8. Un modello da 70B a 4 bit e contesto 128k è 35 GB di pesi e 40 GB di cache.

**Dimensionare per una sola richiesta.** La cache è per sequenza concorrente. Servire otto utenti contemporaneamente richiede otto volte la cache — consulti [qui sotto](https://gpuserver.io/it/guides/vram-sizing#batch).

**Dimenticare l’overhead.** Le attivazioni, il contesto CUDA e la frammentazione dell’allocatore sono reali. Il 15% è un margine deliberatamente prudente; ignorarlo del tutto è il modo in cui un modello che «ci sta» non riesce a caricarsi.

**Sommare la VRAM totale tra più schede.** Quattro schede da 24 GB non sono una scheda da 96 GB. Il tensor parallelism può suddividere un modello tra loro, ma ogni livello deve poi sincronizzarsi sul collegamento — consulti la [guida a NVLink](https://gpuserver.io/it/guides/nvlink-vs-pcie).

**Dimensionare un MoE in base ai parametri attivi.** DeepSeek V3 attiva 37B per token, ma è necessario tenere in memoria tutti i 671B. I parametri attivi prevedono la *velocità*; i parametri totali decidono se il modello si carica affatto.

## Esempi svolti

Memoria totale richiesta, pesi più cache più overhead, a un contesto di 8k e una richiesta. È lo stesso calcolo che il configuratore esegue su ogni configurazione del catalogo.

**VRAM totale richiesta a un contesto di 8k, per modello e precisione**

| Modello | BF16 / FP16 | FP8 | 4-bit (AWQ, GPTQ) | Il nodo più piccolo che ci sta |
|---|---|---|---|---|
| Llama 3.1 8B 8B di parametri | 20 GB | 10 GB | 6 GB | [NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $125/mese · su una scheda · ~34 tok/s |
| Mistral Small 24B 24B di parametri | 57 GB | 28 GB | 15 GB | [NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $125/mese · su una scheda · ~11 tok/s |
| Gemma 3 27B 27B di parametri | 67 GB | 33 GB | 20 GB | [NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $125/mese · su una scheda · ~10 tok/s |
| Qwen 3 32B 32B di parametri | 76 GB | 38 GB | 21 GB | [NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $125/mese · su una scheda · ~8 tok/s |
| Llama 3.3 70B 70B di parametri | 164 GB | 82 GB | 43 GB | [2 × NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $285/mese · suddiviso sul nodo · ~7 tok/s |
| Mixtral 8×22B (MoE) 39B attivi su 141B | 326 GB | 163 GB | 83 GB | [4 × NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $564/mese · suddiviso sul nodo · ~4 tok/s |
| Qwen 3 235B-A22B (MoE) 22B attivi su 235B | 542 GB | 271 GB | 137 GB | [8 × NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $1,106/mese · suddiviso sul nodo · ~10 tok/s |
| DeepSeek V3 671B-A37B (MoE) 37B attivi su 671B | 1,544 GB | 772 GB | 386 GB | [8 × NVIDIA A100 PCIe](https://gpuserver.io/it/gpu/a100-80gb) $7,906/mese · suddiviso sul nodo · ~37 tok/s |
| Llama 3.1 405B 405B di parametri | 936 GB | 468 GB | 237 GB | [10 × NVIDIA L4](https://gpuserver.io/it/gpu/nvidia-l4) $1,371/mese · suddiviso sul nodo · ~3 tok/s |

L’ultima colonna è il nodo più economico del nostro catalogo che contiene il modello a 4 bit e contesto 8k, con la velocità di generazione a flusso singolo consentita dalla larghezza di banda della memoria. I valori di throughput sono deliberatamente conservativi e calibrati su misurazioni pubblicate — li consideri un minimo garantito, non una promessa.

## Servire più di una richiesta

È qui che una macchina dimensionata per una demo diventa una macchina incapace di servire un prodotto. I pesi si pagano una volta sola; la cache si paga per sequenza concorrente.

**VRAM totale per Llama 3.3 70B a 4 bit, per richieste concorrenti e contesto**

| Richieste concorrenti | contesto di 4k | contesto di 8k | contesto di 32k |
|---|---|---|---|
| 1 richiesta | 42 GB una scheda da 80 GB | 43 GB una scheda da 80 GB | 52 GB una scheda da 80 GB |
| 4 richieste | 46 GB una scheda da 80 GB | 52 GB una scheda da 80 GB | 86 GB una H200 |
| 16 richieste | 63 GB una scheda da 80 GB | 86 GB una H200 | 224 GB nodo multi-GPU |
| 64 richieste | 132 GB una H200 | 224 GB nodo multi-GPU | 776 GB nodo multi-GPU |

Llama 3.3 70B a 4 bit sono 35 GB di pesi in ogni caso. Tutto ciò che in quella tabella supera i 35 GB è cache. Ecco perché «funzionava bene sul mio laptop» e «è crollato in produzione» sono lo stesso modello sulla stessa scheda.

**Due modi per recuperare memoria di cache.** Attivi la cache KV FP8 se il suo stack la supporta — dimezza i numeri sopra a un costo in qualità di norma impercettibile. E limiti `--max-model-len` al contesto effettivamente servito: vLLM riserva la cache per il massimo dichiarato, quindi dichiarare 128k quando si serve 8k spreca sedici volte la memoria necessaria.

## Quale macchina ne consegue

Tre regole pratiche che derivano da tutto quanto sopra, nell’ordine in cui contano.

1. **Una scheda sola batte più schede, ogni volta che è possibile.** Niente sharding, niente sincronizzazione tra livelli, nessuna interconnessione a cui pensare. Se il suo modello, al suo contesto, ci sta su una scheda singola, acquisti quella scheda.
2. **Dimensioni in base al contesto reale e alla concorrenza reale**, non al massimo dichiarato dal modello. Il massimo dichiarato è una capacità, non un requisito.
3. **Quando deve suddividere, preferisca NVLink.** Suddividere su quattro schede PCIe funziona; suddividere su quattro schede NVLink funziona ed è sensibilmente più veloce. La [prossima guida](https://gpuserver.io/it/guides/nvlink-vs-pcie) tratta esattamente di quando vale la pena pagare quella differenza.

Il [configuratore](https://gpuserver.io/it/configure) esegue questo calcolo in tempo reale su tutte le 41 configurazioni: scelga un modello, una precisione e una lunghezza di contesto, e Le indicherà quali nodi lo contengono, quali lo contengono su una scheda singola, e quanto costa ciascuno al mese. Usa la formula di questa pagina, quindi se non è d’accordo con i nostri calcoli può ora dire esattamente dove.

## Verifichi il suo modello su ogni macchina che noleggiamo.

Il configuratore esegue il calcolo qui sopra su tutte le 41 configurazioni, prima che paghi qualsiasi cosa.

[Apri il configuratore](https://gpuserver.io/it/configure) [Leggi le guide](https://gpuserver.io/it/guides)

## Altre guide

- [Dimensionamento · 7 min NVLink o PCIe: quale serve al carico di lavoro Quando il collegamento tra le schede decide il throughput, quando non cambia nulla, e come capire in quale caso ci si trova prima di pagare per il nodo sbagliato. Leggi la guida](https://gpuserver.io/it/guides/nvlink-vs-pcie)
- [Dimensionamento · 9 min Scegliere una scheda per modelli di immagine e video Quanta VRAM richiedono FLUX, SDXL, SD 3.5 e Wan 2.1, quale scheda del catalogo li ospita, e perché la più economica che ci sta è raramente quella da noleggiare. Leggi la guida](https://gpuserver.io/it/guides/gpu-for-flux-sdxl)
- [Dimensionamento · 10 min Scegliere un formato di quantizzazione Quanto costano AWQ, GPTQ, GGUF e FP8 in memoria, velocità e qualità — e perché il formato con i pesi più piccoli raramente dà il modello più piccolo. Leggi la guida](https://gpuserver.io/it/guides/awq-vs-gptq-vs-fp8)

---

Fonte: https://gpuserver.io/it/guides/vram-sizing/. Questo file è generato dagli stessi dati del sito web; se una cifra qui differisce da una pagina, la pagina è quella autorevole e questo file è obsoleto — la fonte canonica è https://gpuserver.io/.