Dimensionamento guia · 9 min de leitura

# Quanta VRAM um modelo realmente precisa.

Dois números decidem isso: os pesos, que são fixos, e o cache KV, que cresce conforme o contexto que você atende. Quase toda resposta errada vem de estimar o segundo a partir do primeiro.

A resposta curta

- **Weights:** Parâmetros em bilhões × bytes por parâmetro. 70B em 4 bits é **35 GB**.
- **Cache KV:** 2 × camadas × cabeças KV × dimensão da cabeça × bytes, por token. Nada a ver com a contagem de parâmetros.
- **Overhead:** Adicione cerca de **15%** para ativações, o contexto CUDA e a fragmentação do alocador.
- **A armadilha:** Quantizar os pesos para 4 bits **não** quantiza o cache. Ele permanece em FP16 em toda stack comum.

## A fórmula

Não existe regra prática aqui que sobreviva ao contato com um segundo modelo. O cálculo inteiro tem três linhas, e vale a pena fazê-las em vez de confiar em um multiplicador.

VRAM total, em 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
```

O `2` existe porque há dois tensores por token, K e V. `bytes_per_parameter` é 2 para BF16, 1 para FP8, 0.5 para 4 bits. `cache_bytes` é um número *separado*, e essa separação é a fonte mais comum de uma resposta errada — veja [abaixo](https://gpuserver.io/pt/guides/vram-sizing#wrong).

## Pesos

A metade fácil. É exatamente linear em relação à contagem de parâmetros, e a única decisão é a precisão.

**Memória de pesos por precisão, para uma seleção de tamanhos de modelo**

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

A quantização em 4 bits custa qualidade, e o quanto depende muito mais do modelo do que do método. É a troca certa quando é a diferença entre uma placa e quatro; é uma troca ruim quando você já está confortável.

## O cache KV

A metade difícil, e a que decide se uma máquina é adequada em 4k e inviável em 128k. Ela depende das camadas e das cabeças KV — *não* do tamanho do modelo.

**Dois modelos de tamanhos muito diferentes, lado a lado.** Llama 3.3 70B tem 80 camadas e 8 cabeças KV, então 320 KB por token. Gemma 3 27B — um terço dos parâmetros — tem 62 camadas e 16 cabeças KV, então 496 KB por token, que é 1.6× *mais*. Qualquer estimativa baseada na contagem de parâmetros erra isso ao contrário.

**Tamanho do cache KV por modelo e comprimento de contexto, com precisão de cache em FP16, uma requisição**

| Modelo | Por token | contexto de 4k | contexto de 8k | contexto de 32k | contexto de 128k |
|---|---|---|---|---|---|
| Llama 3.1 8B 32 camadas · 8 cabeças KV | 128 KB | 0.5 GB | 1.0 GB | 4.0 GB | 16.0 GB |
| Gemma 3 27B 62 camadas · 16 cabeças KV | 496 KB | 1.9 GB | 3.9 GB | 15.5 GB | 62.0 GB |
| Llama 3.3 70B 80 camadas · 8 cabeças KV | 320 KB | 1.3 GB | 2.5 GB | 10.0 GB | 40.0 GB |
| DeepSeek V3 671B-A37B (MoE) Atenção latente | 70 KB | 0.3 GB | 0.5 GB | 2.2 GB | 8.8 GB |
| Llama 3.1 405B 126 camadas · 8 cabeças KV | 504 KB | 2.0 GB | 3.9 GB | 15.8 GB | 63.0 GB |

Leia a última coluna antes da primeira. Em contexto de 4k, o cache é um erro de arredondamento em todos os modelos aqui; em 128k, ele é maior que os pesos de um modelo de 70B em 4 bits. O DeepSeek V3 é a exceção porque sua atenção latente comprime o cache por design — por isso ele é utilizável em contexto longo, apesar de ser o maior modelo da lista.

## Onde as estimativas erram

**Dimensionar o cache a partir da contagem de parâmetros.** O erro mais comum, e o mostrado acima. Um modelo de 27B pode precisar de mais cache do que um de 70B.

**Supor que pesos em 4 bits significam um cache em 4 bits.** Não significam. AWQ e GPTQ quantizam apenas os pesos; o cache permanece em FP16, a menos que você ative explicitamente o KV em FP8. Um modelo de 70B em 4 bits e contexto de 128k tem 35 GB de pesos e 40 GB de cache.

**Dimensionar para uma única requisição.** O cache é por sequência simultânea. Atender oito usuários ao mesmo tempo precisa de oito vezes o cache — veja [abaixo](https://gpuserver.io/pt/guides/vram-sizing#batch).

**Esquecer a sobrecarga.** As ativações, o contexto CUDA e a fragmentação do alocador são reais. 15% é uma margem deliberadamente cautelosa; ignorá-la por completo é como um modelo que "cabe" acaba não carregando.

**Contar o total de VRAM entre placas.** Quatro placas de 24 GB não são uma placa de 96 GB. O paralelismo de tensores pode dividir um modelo entre elas, mas cada camada precisa então sincronizar pelo link — veja o [guia de NVLink](https://gpuserver.io/pt/guides/nvlink-vs-pcie).

**Dimensionar um MoE pelos seus parâmetros ativos.** O DeepSeek V3 ativa 37B por token, mas é preciso manter todos os 671B na memória. Os parâmetros ativos preveem *velocidade*; os parâmetros totais decidem se o modelo carrega ou não.

## Exemplos resolvidos

Memória total necessária, pesos mais cache mais sobrecarga, em contexto de 8k e uma requisição. Este é o mesmo cálculo que o configurador roda contra cada configuração do catálogo.

**VRAM total necessária em contexto de 8k, por modelo e precisão**

| Modelo | BF16 / FP16 | FP8 | 4-bit (AWQ, GPTQ) | Menor nó que cabe |
|---|---|---|---|---|
| Llama 3.1 8B 8B de parâmetros | 20 GB | 10 GB | 6 GB | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês · em uma placa · ~34 tok/s |
| Mistral Small 24B 24B de parâmetros | 57 GB | 28 GB | 15 GB | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês · em uma placa · ~11 tok/s |
| Gemma 3 27B 27B de parâmetros | 67 GB | 33 GB | 20 GB | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês · em uma placa · ~10 tok/s |
| Qwen 3 32B 32B de parâmetros | 76 GB | 38 GB | 21 GB | [NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $125/mês · em uma placa · ~8 tok/s |
| Llama 3.3 70B 70B de parâmetros | 164 GB | 82 GB | 43 GB | [2 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $285/mês · dividido pelo nó · ~7 tok/s |
| Mixtral 8×22B (MoE) 39B ativos de 141B | 326 GB | 163 GB | 83 GB | [4 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $564/mês · dividido pelo nó · ~4 tok/s |
| Qwen 3 235B-A22B (MoE) 22B ativos de 235B | 542 GB | 271 GB | 137 GB | [8 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $1,106/mês · dividido pelo nó · ~10 tok/s |
| DeepSeek V3 671B-A37B (MoE) 37B ativos de 671B | 1,544 GB | 772 GB | 386 GB | [8 × NVIDIA A100 PCIe](https://gpuserver.io/pt/gpu/a100-80gb) $7,906/mês · dividido pelo nó · ~37 tok/s |
| Llama 3.1 405B 405B de parâmetros | 936 GB | 468 GB | 237 GB | [10 × NVIDIA L4](https://gpuserver.io/pt/gpu/nvidia-l4) $1,371/mês · dividido pelo nó · ~3 tok/s |

A última coluna é o nó mais barato do nosso catálogo que comporta o modelo em 4 bits e contexto de 8k, com a taxa de geração em fluxo único que a largura de banda de memória permite. Os números de throughput são deliberadamente conservadores e calibrados com base em medições publicadas — trate-os como um piso, não uma promessa.

## Atendendo mais de uma requisição

É aqui que uma máquina dimensionada para uma demonstração vira uma máquina incapaz de atender um produto. Os pesos são pagos uma vez; o cache é pago por sequência simultânea.

**VRAM total para Llama 3.3 70B em 4 bits, por requisições simultâneas e contexto**

| Requisições simultâneas | contexto de 4k | contexto de 8k | contexto de 32k |
|---|---|---|---|
| 1 requisição | 42 GB uma placa de 80 GB | 43 GB uma placa de 80 GB | 52 GB uma placa de 80 GB |
| 4 requisições | 46 GB uma placa de 80 GB | 52 GB uma placa de 80 GB | 86 GB uma H200 |
| 16 requisições | 63 GB uma placa de 80 GB | 86 GB uma H200 | 224 GB nó multi-GPU |
| 64 requisições | 132 GB uma H200 | 224 GB nó multi-GPU | 776 GB nó multi-GPU |

Llama 3.3 70B em 4 bits são 35 GB de pesos, faça o que fizer. Tudo acima de 35 GB nessa tabela é cache. É por isso que "rodou bem no meu notebook" e "caiu em produção" são o mesmo modelo na mesma placa.

**Duas formas de recuperar memória de cache.** Ative o cache KV em FP8 se a sua stack for compatível — isso reduz os números acima pela metade, com um custo de qualidade geralmente imperceptível. E limite `--max-model-len` ao contexto que você realmente atende: o vLLM reserva cache para o máximo declarado, então declarar 128k quando você atende 8k desperdiça dezesseis vezes a memória de que você precisa.

## Qual máquina isso representa

Três regras práticas que decorrem de tudo acima, na ordem de importância.

1. **Uma placa é melhor que várias, sempre que possível.** Sem sharding, sem sincronização entre camadas, sem interconexão para se preocupar. Se o seu modelo, no seu contexto, cabe em uma única placa, compre essa placa.
2. **Dimensione para o seu contexto real e a sua concorrência real**, não para o máximo anunciado do modelo. O máximo anunciado é uma capacidade, não um requisito.
3. **Quando precisar fazer sharding, prefira NVLink.** Dividir entre quatro placas PCIe funciona; dividir entre quatro placas NVLink funciona e é significativamente mais rápido. O [próximo guia](https://gpuserver.io/pt/guides/nvlink-vs-pcie) trata exatamente de quando essa diferença vale a pena pagar.

O [configurador](https://gpuserver.io/pt/configure) roda esse cálculo em tempo real contra todas as 41 configurações: escolha um modelo, uma precisão e um comprimento de contexto, e ele diz quais nós o comportam, quais o comportam em uma única placa, e quanto cada um custa por mês. Ele usa a fórmula desta página, então, se você discordar da nossa aritmética, agora pode dizer exatamente onde.

## Verifique seu próprio modelo contra cada máquina que alugamos.

O configurador faz a aritmética acima para todas as 41 configurações, antes de você pagar qualquer coisa.

[Abrir o configurador](https://gpuserver.io/pt/configure) [Ler os guias](https://gpuserver.io/pt/guides)

## Outros guias

- [Dimensionamento · 7 min NVLink ou PCIe: de qual seu trabalho precisa Quando o link entre placas decide seu throughput, quando não muda nada, e como saber em qual caso você está antes de pagar pelo nó errado. Ler o guia](https://gpuserver.io/pt/guides/nvlink-vs-pcie)
- [Dimensionamento · 9 min Escolhendo uma placa para modelos de imagem e vídeo O que FLUX, SDXL, SD 3.5 e Wan 2.1 precisam em VRAM, qual placa do nosso catálogo comporta cada um, e por que a mais barata que cabe raramente é a certa para alugar. Ler o guia](https://gpuserver.io/pt/guides/gpu-for-flux-sdxl)
- [Dimensionamento · 10 min Escolhendo um formato de quantização O que AWQ, GPTQ, GGUF e FP8 custam em memória, velocidade e qualidade — e por que o formato com os menores pesos raramente dá o menor modelo. Ler o guia](https://gpuserver.io/pt/guides/awq-vs-gptq-vs-fp8)

---

Fonte: https://gpuserver.io/pt/guides/vram-sizing/. Este arquivo é gerado a partir dos mesmos dados que o site; se um número aqui divergir de uma página, a página prevalece e este arquivo está desatualizado — a fonte canônica é https://gpuserver.io/.