A VRAM é o recurso mais crítico — e mais mal dimensionado — em projetos de IA. Compre pouco e o modelo não roda. Compre muito e você imobilizou capital desnecessário. Este guia mostra como calcular exatamente quanto de VRAM você precisa para cada caso de uso.
O que é VRAM e por que limita o modelo
VRAM (Video RAM) é a memória dedicada instalada na GPU. Diferente da RAM do sistema, a VRAM é co-localizada com os núcleos de processamento da GPU — dados que estão na VRAM são acessados em nanosegundos; dados na RAM do sistema precisam atravessar o barramento PCIe (10–30 GB/s), que é ordens de magnitude mais lento que o bandwidth interno da GPU (1–3 TB/s).
Para um modelo de IA rodar com eficiência, todos os pesos do modelo precisam caber na VRAM. Se não couberem, o framework faz offload para RAM do sistema — e a performance pode cair 10–50× dependendo do tamanho do modelo e do volume de dados que precisa ser transferido via PCIe.
Como calcular a VRAM necessária
Fórmula base para pesos do modelo
VRAM pesos (GB) = (Parâmetros × bytes_por_parâmetro) / 1.073.741.824 Precisão bytes_por_parâmetro ───────────────────────────────────── FP32 (float32) 4 bytes FP16 / BF16 2 bytes INT8 (8-bit quant) 1 byte INT4 / Q4 (4-bit) 0,5 byte
Exemplo: Llama 3 70B em BF16 = 70.000.000.000 × 2 / 1.073.741.824 ≈ 130 GB
VRAM total = pesos + KV-cache + overhead
Para inferência, você precisa somar:
- Pesos do modelo: calculado acima
- KV-cache: memória para armazenar o contexto da conversa. Para um modelo com 32 camadas e contexto de 8.192 tokens em BF16, o KV-cache consome ~8–16 GB dependendo da arquitetura
- Overhead do framework: CUDA runtime, buffers de ativação — normalmente 1–3 GB
Regra prática: adicione 20–30% sobre o tamanho dos pesos para ter margem de KV-cache e overhead.
Tabela: VRAM por modelo e precisão
| Modelo | FP16/BF16 | INT8 | Q4 | GPU mínima (Q4) |
|---|---|---|---|---|
| Phi-3.5 Mini (3,8B) | 8 GB | 4 GB | 2 GB | RTX 3060 (12 GB) |
| Llama 3.2 3B | 6 GB | 3 GB | 2 GB | RTX 3060 (12 GB) |
| Mistral 7B / Llama 3 8B | 16 GB | 8 GB | 5 GB | RTX 4060 Ti (16 GB) |
| Llama 3 13B | 26 GB | 13 GB | 7 GB | RTX 4090 (24 GB) + Q6 |
| Qwen 2.5 32B | 65 GB | 33 GB | 20 GB | L40S (48 GB) via Q4 |
| Llama 3 70B | 130 GB | 65 GB | 38 GB | L40S (48 GB) via Q4 |
| Llama 3.1 405B | 810 GB | 405 GB | 228 GB | 3× A100 80 GB via Q4 |
| Modelos de embedding (e5-large) | 1,3 GB | 0,7 GB | — | Qualquer GPU moderna |
Treinamento vs inferência: VRAM diferente
Para inferência, você precisa carregar apenas os pesos do modelo + KV-cache. Para treinamento completo (full fine-tuning), a conta é muito maior:
- Pesos do modelo (FP32): 4 bytes por parâmetro
- Gradientes: mais 4 bytes por parâmetro
- Optimizer states (Adam): mais 8 bytes por parâmetro (momentum + variance)
- Ativações: dependem do batch size e da arquitetura
Total para full fine-tuning com Adam: ~16 bytes por parâmetro — 8× mais que inferência em FP16.
Um modelo de 7B em full fine-tuning precisa de ~112 GB de VRAM. Para isso caber em hardware acessível, usa-se:
- LoRA / QLoRA: treina apenas adaptadores leves (0,1–1% dos parâmetros). Um modelo de 7B com QLoRA roda em 8–12 GB de VRAM.
- Gradient checkpointing: recomputa ativações durante o backward pass em vez de armazená-las — troca VRAM por computação extra (treinamento ~20% mais lento, mas cabe em GPUs menores).
- Mixed precision (BF16): treina em BF16 com master weights em FP32 — reduz o consumo de VRAM em ~40%.
Técnicas para compensar VRAM insuficiente
1. Quantização (inferência)
Reduz a precisão dos pesos de FP16 para INT8 ou INT4. Com Q4_K_M (formato GGUF), um modelo de 70B cai de 130 GB para ~38 GB com perda de qualidade mínima (perplexidade aumenta ~1–3%). Ferramentas: llama.cpp (CPU+GPU), Ollama, vLLM com AutoGPTQ.
2. Model parallelism (múltiplas GPUs)
Divide o modelo entre múltiplas GPUs — cada GPU segura uma fatia dos layers. Dois L40S de 48 GB = 96 GB de VRAM efetiva, suficiente para Llama 3 70B em FP16. Frameworks: Hugging Face Accelerate, DeepSpeed, Tensor Parallelism no vLLM.
3. CPU offloading
Llama.cpp e llama-cpp-python suportam offload parcial: parte dos layers fica na GPU (rápido), o restante na RAM do sistema (lento mas funcional). Para uma RTX 4090 (24 GB) rodando Llama 70B Q4 (38 GB), é possível colocar 30 layers na GPU e 10 na RAM — throughput cai para ~5–10 tok/s mas o modelo roda.
4. FlashAttention 2
Algoritmo de atenção que reduz o consumo de VRAM das ativações de O(n²) para O(n) em relação ao tamanho do contexto. Essencial para contextos longos (32k–128k tokens). Suporte nativo no PyTorch 2.1+ e na maioria dos frameworks modernos.
Perguntas frequentes
Posso somar a VRAM de GPUs diferentes para rodar modelos maiores?
Sim, com frameworks que suportam model parallelism (Hugging Face Accelerate, DeepSpeed, vLLM). A GPU não precisa ser do mesmo modelo, mas GPUs diferentes têm bandwidths diferentes — o mais lento vira o gargalo. O ideal é usar GPUs iguais. NVLink (disponível em A100 e H100) oferece comunicação entre GPUs muito mais rápida que PCIe, reduzindo o overhead do model parallelism.
Q4 é bom o suficiente para uso em produção?
Depende do caso de uso. Para chatbots internos, Q&A sobre documentos e geração de texto geral, Q4_K_M tem qualidade praticamente indistinguível de FP16 em testes cegos. Para tarefas que exigem alta precisão numérica, raciocínio matemático complexo ou geração de código crítico, Q8 ou FP16 são preferíveis. O formato Q4_K_M do llama.cpp é atualmente o ponto ideal entre tamanho e qualidade para a maioria das aplicações empresariais.
VRAM e RAM do sistema são intercambiáveis?
Não diretamente. A GPU acessa a VRAM a 1–3 TB/s; acessar RAM do sistema via PCIe é 10–30 GB/s — 30–100× mais lento. Frameworks como llama.cpp permitem partial offload (parte do modelo na VRAM, parte na RAM), mas o throughput cai proporcionalmente à fração que está na RAM. Para produção com requisitos de latência, o modelo precisa estar 100% na VRAM.
Quantos usuários simultâneos suporto com uma RTX 4090 e Llama 3 8B Q4?
Com vLLM em modo de batching contínuo, uma RTX 4090 (24 GB) rodando Llama 3 8B Q4 (~5 GB de pesos) tem ~19 GB livres para KV-cache. Cada sessão de conversa ativa consome 1–4 GB de KV-cache dependendo do tamanho do contexto. Na prática, 4–8 sessões concorrentes com contextos de 4k tokens. Para mais usuários, adicione GPUs ou use um modelo menor (Llama 3.2 3B).
