Calculadora de VRAM para LLM local
Um modelo de 7B com 4 bits precisa de cerca de 3,3 GiB para os pesos, e um da classe Llama 3.1 8B soma cerca de 1 GiB de cache KV a cada 8.192 tokens de contexto.
Como usar
- Escolha um modelo pronto para preencher parâmetros, camadas, cabeças KV e dimensão da cabeça, ou escolha Personalizado e digite os valores do config.json do modelo.
- Defina os bits de quantização dos pesos (4 para Q4, 16 para FP16) e a precisão do cache KV.
- Informe o tamanho do contexto em tokens e o tamanho do lote, ou seja, quantas sequências rodam ao mesmo tempo.
- Veja o total e a divisão em pesos, cache KV e overhead. A tabela mostra em quais tamanhos comuns de GPU o modelo cabe.
Como é calculado
Memória dos pesos = parâmetros × bits ÷ 8 bytes. Um modelo de 7 bilhões de parâmetros com 4 bits ocupa 7.000.000.000 × 0,5 = 3,5 GB, ou 3,26 GiB. Com 16 bits são 14 GB, o que bate com a regra de 2 GB por bilhão de parâmetros em bfloat16 do guia da Hugging Face "Optimizing LLMs for Speed and Memory".
Cache KV = 2 × camadas × cabeças KV × dimensão da cabeça × tamanho do contexto × tamanho do lote × bytes por valor. O 2 é de chaves e valores. A Hugging Face traz a forma por token, 2 × 2 × camadas × cabeças KV × dimensão da cabeça para valores de 16 bits, no post "Unlocking Longer Generation with Key-Value Cache Quantization".
O overhead é informado como porcentagem de pesos mais cache KV. Ele representa o contexto CUDA, os buffers de ativação e a fragmentação de memória. Os 10% padrão são uma suposição, não um valor medido.
Todos os resultados estão em GiB (1 GiB = 1.073.741.824 bytes). Os fabricantes de GPU escrevem "24 GB" para uma placa de 24 GiB, então a tabela compara o total direto com 8, 12, 16, 24, 48 e 80. É uma estimativa. O uso real muda conforme o framework (llama.cpp, vLLM, Ollama, Transformers), os kernels e a forma como o cache é alocado.
O que ocupa a VRAM
Duas coisas dominam. Os pesos ficam fixos depois que modelo e quantização são escolhidos. O cache KV cresce a cada token do contexto e a cada sequência do lote, e é por isso que, com contexto longo ou muitos usuários em paralelo, um modelo que "cabia" de repente deixa de caber.
Modelos com atenção de consulta agrupada (GQA) têm menos cabeças KV do que cabeças de atenção, o que reduz o cache várias vezes. Por isso o campo de cabeças KV importa mais que o número de cabeças de atenção. Confira num_key_value_heads no config.json do modelo.
Tamanho dos pesos por bilhão de parâmetros
| Bits por peso | GiB por 1B de parâmetros | Exemplo: modelo de 8B |
|---|---|---|
| 16 (FP16 / BF16) | 1,86 | 14,90 GiB |
| 8 (INT8 / Q8) | 0,93 | 7,45 GiB |
| 6 (Q6) | 0,70 | 5,59 GiB |
| 5 (Q5) | 0,58 | 4,66 GiB |
| 4 (Q4) | 0,47 | 3,73 GiB |
| 3 (Q3) | 0,35 | 2,79 GiB |
| 2 (Q2) | 0,23 | 1,86 GiB |
De onde vêm os modelos prontos
- config.json de cada repositório: huggingface.co/Qwen/Qwen2.5-{7B,14B,32B,72B}, huggingface.co/Qwen/Qwen3-{8B,32B}, huggingface.co/mistralai/Mistral-7B-v0.3, huggingface.co/mistralai/Mistral-Nemo-Base-2407, huggingface.co/microsoft/phi-4.
- Llama 3.1 8B e 70B: os config.json da Meta exigem aprovação na Hugging Face, então os valores vêm da Tabela 3 do artigo da Meta "The Llama 3 Herd of Models" (arXiv 2407.21783). Gemma 2 9B e 27B: Tabela 1 do relatório do Google "Gemma 2" (arXiv 2408.00118).
- A contagem de parâmetros é o total de safetensors que a API da Hugging Face mostra para cada repositório. Se o config.json não tem head_dim, usa-se hidden_size ÷ cabeças de atenção.
Perguntas frequentes
Quanta VRAM um modelo de 7B com 4 bits precisa?
Cerca de 3,3 GiB só de pesos. Com contexto de 8.192 tokens num modelo da classe Llama 3.1 8B, o cache KV soma cerca de 1 GiB, então conte com uns 5 GiB incluindo o overhead. Uma placa de 8 GB roda e ainda sobra espaço para mais contexto.
Uma placa de 24 GB roda um modelo de 32B?
Com 4 bits, sim. O Qwen2.5 32B tem cerca de 32,76 bilhões de parâmetros, então os pesos ocupam uns 15,3 GiB. Com 8.192 tokens de contexto o cache KV é de 2 GiB, e com 10% de overhead o total fica perto de 19 GiB.
Por que meu uso real difere da estimativa?
Os frameworks têm overhead diferente. O vLLM reserva antecipadamente a maior parte da GPU para o cache KV e faz preempção de requisições quando falta espaço, o llama.cpp aloca o cache do contexto inteiro logo no início, e as K-quants do GGUF guardam valores de escala extras, então os bits efetivos ficam acima do número nominal. Aumente os bits ou o overhead se aparecerem erros de memória.
Funciona para modelos de mistura de especialistas?
Os pesos continuam precisando caber na memória, então informe o total de parâmetros, não os ativos. O cache KV depende só das camadas de atenção, então use camadas e cabeças KV do config. Os modelos prontos aqui são densos.
O Gemma 2 usa janela deslizante. A estimativa é menor?
O Gemma 2 alterna camadas locais com janela de 4.096 tokens e camadas globais. A ferramenta conta o contexto inteiro em todas as camadas, então dá um limite superior para o Gemma 2 quando o contexto é maior que a janela.