Key Takeaways
- Modelos 7B: mínimo 8 GB (Q4), confortável com 10 GB (Q5), 14 GB para Q8 precisão completa.
- Modelos 13B: mínimo 10 GB (Q4), confortável com 12-14 GB (Q5), 16 GB para Q8.
- Modelos 70B: mínimo 24 GB (Q4), 32 GB+ para Q5/Q8 ou configuração multiusuário.
- A quantização (Q4, Q5, Q8) reduz a VRAM em 50-75% em relação à precisão completa (FP32).
- Sempre superdimensione 1-2 GB para o overhead (cache KV, estado do otimizador, sistema operacional).
- O batch size ≠ VRAM por inferência. A inferência única usa a mesma VRAM independentemente do batch (o batch processa sequencialmente).
- Mais VRAM não acelera a inferência de um único prompt. Só ajuda em configurações multiusuário/multi-requisição.
Regra geral de VRAM — Referência rápida
Sem tempo para a fórmula? Use estas regras simples:
Assim que souber seu orçamento de VRAM, veja quais GPUs se encaixam em cada nível →
- Modelos 3B (Phi, StableLM): mínimo 4 GB de VRAM
- Modelos 7B (Llama, Mistral, Qwen): 8 GB de VRAM (Q4), 10 GB (Q5)
- Modelos 13B (Llama 3.3, Mistral): mínimo 12 GB de VRAM (Q4)
- Modelos 22B (Qwen3, Gemma): 16 GB de VRAM (Q4)
- Modelos 70B (Llama 3.3, Qwen 3.6): 24–32 GB de VRAM (Q4–Q5)
- Modelos MoE: a VRAM escala com os pesos que você precisa manter na memória. Exemplo: Qwen 3.6 35B-A3B (3B ativos) cabe em uma pegada minúscula de ~2 GB, enquanto o Llama 4 Scout (17B ativos / 109B totais) ainda precisa de ~55 GB em Q4 porque todos os especialistas permanecem residentes
# Quick VRAM formula (memorize this)
VRAM (GB) ≈ Model Size (B) ÷ 8 # at Q4 quantization
# Examples:
7B ÷ 8 = 0.875 GB per billion ≈ 8 GB total
70B ÷ 8 = 8.75 GB per billion ≈ 48 GB total
# For other quantizations:
Q8 (8-bit): Model Size ÷ 4
Q5 (5-bit): Model Size ÷ 5
FP32 (full): Model Size × 4Qual é a fórmula de VRAM para LLMs?
VRAM (GB) = (Tamanho do modelo em bilhões × 4 bytes × Fator de quantização)
- Tamanho do modelo: Número de parâmetros (7B, 13B, 70B, etc.)
- 4 bytes: precisão FP32 (1 byte = 8 bits)
- Fator de quantização: 1.0 (FP32), 0.5 (Q8), 0.25 (Q4)
Exemplo: Llama 3 70B, FP32, sem quantização:
70 bilhões × 4 bytes = 280 GB. Impraticável.
Llama 3 70B, quantização Q4 (4 bits):
70 bilhões × 4 bytes × 0.25 = 70 GB alocados, ~24 GB usados após a compressão.
Modelos MoE (Esparsos): Os parâmetros ativos determinam o processamento, mas todos os especialistas precisam permanecer carregados na VRAM. Exemplo: o Llama 4 Scout tem 109B de parâmetros totais com 17B ativos por token. Em Q4 ainda precisa de ~55 GB de VRAM para manter todos os especialistas — só entra em uma GPU de 24 GB com um quant agressivo de 1.78 bits (~20 tok/s). O processamento é barato; a memória é a restrição.
Quanta VRAM cada tamanho de modelo precisa?
| Tamanho do modelo | FP32 (sem quantização) | Q8 (8 bits) | Q5 (5 bits) | Q4 (4 bits) | GPU recomendada |
|---|---|---|---|---|---|
| 3B (Phi, StableLM) | 12 GB | 6 GB | 4 GB | 3 GB | RTX 2060 6 GB ou RTX 5070 12 GB |
| 7B (Llama 3.3, Mistral) | 28 GB | 14 GB | 9 GB | 7 GB | RTX 3060 12 GB ou RTX 5070 12 GB |
| 13B (Llama 3.3, Mistral) | 52 GB | 26 GB | 17 GB | 13 GB | RTX 3090 24 GB ou RTX 5080 16 GB |
| 22B (Qwen, Gemma) | 88 GB | 44 GB | 28 GB | 22 GB | RTX 4090 24 GB (Q4) ou RTX 5090 32 GB |
| 70B (Llama 3, Qwen) | 280 GB | 140 GB | 88 GB | 70 GB | 2× RTX 4090 (24 GB cada), ou 1× H100 80 GB |
| Qwen 3.6 35B-A3B (3B ativos, MoE)* | 12 GB | 3 GB | 2 GB | 2 GB | RTX 2060 6 GB ou RTX 5070 12 GB |
| DeepSeek V4-Flash (13B ativos / 284B total, MoE)* | 52 GB | 13 GB | 8 GB | 7 GB | RTX 3060 12 GB ou RTX 5070 12 GB |
| Llama 4 Scout (17B ativos / 109B total, MoE)† | 436 GB | 109 GB | 68 GB | 55 GB | 2× RTX 4090 (48 GB) — entra em 24 GB só a 1.78 bits (~20 tok/s) |
| gpt-oss:20b (3.6B ativos / 21B total, MoE)* | 84 GB | 21 GB | 13 GB | 12 GB | RTX 5070 12 GB ou qualquer GPU de 16 GB |
| Kimi K2.6 (32B ativos / 1T total, MoE)* | 128 GB | 32 GB | 20 GB | 16 GB | 2× RTX 4090 ou RTX 5090 32 GB (só Q4) |
* Modelos MoE: a VRAM é calculada apenas a partir dos parâmetros ativos, não do tamanho total do modelo. † O Llama 4 Scout mantém os 109B parâmetros residentes, então precisa de ~55 GB em Q4 apesar de ter apenas 17B ativos por token.
Modelos MoE precisam de muito menos VRAM do que o tamanho sugere
Os modelos Mixture-of-Experts (MoE) distribuem seus parâmetros entre muitas sub-redes "especialistas" e ativam apenas uma fração para cada token. Os parâmetros ativos reduzem o processamento e aceleram a inferência, mas na maioria dos modelos MoE todos os especialistas precisam permanecer carregados na VRAM — então o uso de memória segue o total de parâmetros, não os ativos.
Regra para modelos densos: VRAM = parâmetros_totais × bytes_por_parâmetro
Regra para modelos MoE (processamento): os parâmetros_ativos determinam os tokens/seg — mas a VRAM ainda escala com os pesos totais residentes.
Exemplo: o Llama 4 Scout tem 109B de parâmetros totais com apenas 17B ativos por token. É rápido para o seu tamanho, mas em Q4 ainda precisa de ~55 GB de VRAM para manter todos os especialistas — fora do alcance de uma única GPU de 24 GB, salvo com um quant agressivo de 1.78 bits (~20 tok/s em uma RTX 4090).
Alguns runtimes podem transmitir ou descarregar os especialistas inativos para a RAM do sistema, sacrificando velocidade por uma pegada de VRAM menor. A conclusão-chave: não assuma que um modelo MoE cabe em uma VRAM do tamanho dos seus parâmetros ativos — verifique o tamanho real em disco para o seu nível de quantização.
Como a quantização reduz os requisitos de VRAM?
A quantização reduz o número de bits necessários para representar cada parâmetro do modelo.
- FP32 (float de 32 bits): Precisão completa. 1 parâmetro = 4 bytes. Sem perda. Mais lento.
- Q8 (8 bits): 1 parâmetro = 1 byte. ~6% de perda de precisão. 75% de economia de VRAM.
- Q5 (5 bits): 1 parâmetro = 0.625 bytes. ~2% de perda de precisão. 84% de economia de VRAM.
- Q4 (4 bits): 1 parâmetro = 0.5 bytes. ~1% de perda de precisão. 87.5% de economia de VRAM.
Para a maioria dos usuários, o Q4 é o ponto ideal: perda de precisão imperceptível, pegada de VRAM 87% menor.
A partir de abril de 2026, o Q4 é o padrão. Q5 e Q8 estão disponíveis se você tiver VRAM de sobra e quiser ganhos marginais de qualidade.
A VRAM determina o tamanho do modelo, mas o design do prompt determina a qualidade da saída. Técnicas como chain-of-thought e few-shot prompting podem fechar a diferença de qualidade entre modelos menores e maiores. Explore o completo toolkit de engenharia de prompts para extrair mais dos modelos que seu hardware suporta. Se você tem 12–16 GB de VRAM e quer uma carga de trabalho de programação concreta para testar esse toolkit, Substituir o GitHub Copilot por um LLM local mapeia o stack Continue.dev + Ollama + Qwen3-Coder exatamente para esses níveis de VRAM.
E quanto ao batch size e à inferência multiusuário?
O batch size afeta a vazão (tokens por segundo), não a latência de uma inferência individual.
Um único usuário que pergunta "Quanto é 2+2?" usa a mesma VRAM independentemente de o batch size ser 1 ou 32.
Batch size = 32 significa processar 32 prompts em paralelo. Isso usa ~32× mais VRAM, mas gera 32 respostas mais rápido.
Para usuário único (uso típico de LLM local): Batch size = 1. A VRAM é o tamanho do modelo + 1-2 GB de overhead.
Para servidor multiusuário: Aloque batch size × VRAM do modelo. Um modelo 70B com batch=4 precisa de ~96 GB (24 GB × 4).
Você precisa de mais VRAM que o tamanho do modelo?
Sim. Além dos pesos do modelo, adicione:
- Cache KV (cache chave-valor para o contexto): ~5-10% de VRAM adicional.
- Estado do otimizador (se fizer fine-tuning): 2-4× o tamanho do modelo (relevante só para treinamento, não para inferência).
- Overhead do sistema (SO, drivers, runtime do Ollama/LM Studio): ~1-2 GB.
Regra: Um modelo 70B Q4 (20 GB) + cache KV (2 GB) + sistema (2 GB) = ~24 GB alocados.
Sempre compre GPUs com pelo menos 1-2 GB de margem acima dos mínimos teóricos.
Erros comuns sobre VRAM
- Mais VRAM = inferência mais rápida. Falso. O tamanho da VRAM não afeta a velocidade. A largura de banda de memória (GB/seg) sim, e é fixa por GPU.
- O batch size = limite sequencial de tokens. Falso. Batch size = requisições em paralelo. A inferência individual usa batch=1 independentemente do tamanho da VRAM.
- Você precisa de 24 GB para qualquer modelo 70B. Falso. Q4 precisa de 24 GB. Q8 precisa de 48 GB. Depende da quantização.
Calculadora de VRAM
Selecione o tamanho do seu modelo e a quantização para estimar os requisitos de VRAM.
Popular Models
Base Model
6.50 GB
Context OH
1.50 GB
Batch OH
0.00 GB
System OH
1.00 GB
Total Minimum
9.00 GB
Recommended (with 25% safety margin)
11.25 GB
👉 Look for a GPU with at least 11.25 GB VRAM
Compatible GPUs
RTX 3060 (12 GB)
0.8 GB headroom
RTX 4070 (12 GB)
0.8 GB headroom
RTX 4070 Ti (12 GB)
0.8 GB headroom
RTX 4080 (16 GB)
4.8 GB headroom
RTX 4090 (24 GB)
12.8 GB headroom
Mac mini M5 (16 GB) (16 GB)
4.8 GB headroom
Mac mini M4 (16 GB) (16 GB)
4.8 GB headroom
MacBook Pro (24 GB) (24 GB)
12.8 GB headroom
M3 Max (36 GB) (36 GB)
24.8 GB headroom
💡 Pro Tips:
- Always use the "with safety margin" figure when buying a GPU
- Q4 gives 90-95% quality with 25% size reduction. Q5 is better if you have room
- Context overhead grows with conversation length. Budget 1-3 GB for typical usage
- Batch size matters for multi-user APIs. Single-user chat can ignore batch overhead
📋 Share this configuration:
Perguntas frequentes
Posso rodar o Mistral Small em uma GPU de 6 GB?
Com dificuldade, em Q4 com overhead apertado. Na prática, não. Compre pelo menos 8 GB. Você terá erros de OOM com 6 GB.
Quanta VRAM preciso para fazer fine-tuning de um modelo 7B?
Para LoRA: 12-16 GB. Fine-tuning completo: 28 GB+. O fine-tuning exige estado do otimizador (2-4× a VRAM do modelo), não só a inferência.
12 GB são suficientes para o Llama 3 13B?
Em Q4, mal. Em Q5 ou Q8, não. 12 GB é muito apertado. 16 GB é confortável.
Preciso de 24 GB para um modelo 70B?
Em Q4, sim. Em Q5+, não. Uma quantização mais alta (Q5, Q8) precisa de 32 GB+ para 70B.
Aumentar o batch size reduz a VRAM para inferência individual?
Não. A inferência individual sempre usa a VRAM de batch=1. O batch size só ajuda a vazão (cenários multiusuário).
Qual é a melhor quantização para a precisão?
O Q8 tem perda quase imperceptível. O Q5 tem ~2% de perda. O Q4 tem ~1% de perda. Para a maioria, o Q4 é o ponto ideal.
Posso descarregar parte da VRAM para a RAM da CPU?
Sim, via divisão de camadas (NVLink). O llama.cpp e o Ollama suportam isso. A vazão cai 30-50%, mas funciona. Menos de 8 GB de VRAM? Veja **quais modelos rodam mais rápido no seu nível exato de hardware** — benchmarks com números reais de tok/seg para apenas CPU, 4 GB, 6 GB e 8 GB de VRAM.
Fontes
- Documentação da arquitetura de memória CUDA e do modelo de memória compartilhada da NVIDIA
- Documentação oficial do Ollama e do LM Studio: requisitos de VRAM para modelos e especificações de quantização
- Projeto llama.cpp no GitHub: níveis de quantização (Q4, Q5, Q8) e cálculos de memória