Key Takeaways
- Modelos 7B: ~4 GB de pesos em Q4, ~5 GB em Q5, ~7 GB em Q8. Adicione 1-2 GB de margem para uma recomendação real de 6-8 GB.
- Modelos 13B: ~8 GB de pesos em Q4, ~9 GB em Q5, ~14 GB em Q8. 12 GB de VRAM é confortável, não "mal suficiente".
- Modelos 70B: ~42 GB de pesos em Q4, ~50 GB em Q5, ~74 GB em Q8. Reserve mais para configurações 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): ~2 GB de pesos em Q4, 4 GB de VRAM recomendada com margem
- Modelos 7B (Llama, Mistral, Qwen): ~4 GB de pesos em Q4, 6-8 GB de VRAM recomendada
- Modelos 13B (Llama 3.3, Mistral): ~8 GB de pesos em Q4, 10-12 GB de VRAM recomendada
- Modelos 22B (Qwen3, Gemma): ~13 GB de pesos em Q4, 16 GB de VRAM recomendada
- Modelos 70B (Llama 3.3, Qwen 3.6): ~42 GB de pesos em Q4, 48 GB de VRAM recomendada, 50+ GB em 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) × 0.6 # at Q4 quantization
# Examples:
7B × 0.6 = 4.2 GB
70B × 0.6 = 42 GB
# For other quantizations (bytes per parameter):
Q8 (8-bit): Model Size × 1.05
Q5 (5-bit): Model Size × 0.7
FP32 (full): Model Size × 4
# Verified against real GGUF file sizes (Hugging Face):
# Llama-2-7B Q4_K_M = 4.08 GB, Mistral-Small-24B Q4_K_M = 14.33 GB,
# Llama-3.3-70B Q4_K_M = 42.52 GBQual é a fórmula de VRAM para LLMs?
VRAM (GB) = Tamanho do modelo em bilhões × Bytes por parâmetro
- Tamanho do modelo: Número de parâmetros (7B, 13B, 70B, etc.)
- Bytes por parâmetro: 4,0 (FP32, precisão completa), ~1,05 (Q8, 8 bits), ~0,7 (Q5, 5 bits), ~0,6 (Q4, 4 bits)
- Esses números foram verificados contra tamanhos reais de arquivos GGUF no Hugging Face, não apenas a largura de bits teórica -- formatos reais como Q4_K_M carregam uma pequena sobrecarga acima do mínimo teórico de 4 bits (0,5 bytes/parâmetro).
Exemplo: Llama 3.3 70B, FP32, sem quantização:
70 bilhões × 4,0 bytes = 280 GB. Impraticável em hardware de consumo.
Llama 3.3 70B, quantização Q4 (4 bits):
70 bilhões × 0,6 bytes = 42 GB. (O GGUF Q4_K_M real do Llama-3.3-70B-Instruct tem 42,52 GB.)
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 | 3 GB | 2 GB | 2 GB | RTX 3050 4 GB ou RTX 2060 6 GB |
| 7B (Llama 3.3, Mistral) | 28 GB | 7 GB | 5 GB | 4 GB | RTX 4060 8 GB ou RTX 3060 12 GB |
| 13B (Llama 3.3, Mistral) | 52 GB | 14 GB | 9 GB | 8 GB | RTX 3060 12 GB ou RTX 4070 12 GB |
| 22B (Qwen, Gemma) | 88 GB | 23 GB | 15 GB | 13 GB | RTX 4080 16 GB ou RTX 4090 24 GB |
| 70B (Llama 3, Qwen) | 280 GB | 74 GB | 50 GB | 42 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 | 14 GB | 9 GB | 8 GB | RTX 3060 12 GB ou RTX 5070 12 GB |
| Llama 4 Scout (17B ativos / 109B total, MoE)† | 436 GB | 114 GB | 76 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 | 22 GB | 15 GB | 12 GB | RTX 5070 12 GB ou qualquer GPU de 16 GB |
| Kimi K2.6 (32B ativos / 1T total, MoE)* | 128 GB | 34 GB | 22 GB | 19 GB | 2× RTX 4090 ou RTX 5090 32 GB (só Q4) |
Os números são tamanhos de pesos puros, verificados contra tamanhos reais de arquivos GGUF no Hugging Face (ex.: Llama-2-7B Q4_K_M = 4,08 GB, Mistral-Small-24B Q4_K_M = 14,33 GB, Llama-3.3-70B Q4_K_M = 42,52 GB) -- adicione 1-2 GB de margem para contexto/cache KV. * 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.
Melhor LLM local por nível de VRAM
A maioria das pessoas já sabe quanta VRAM sua GPU tem e quer a busca inversa: "tenho 12 GB — qual é o melhor modelo?" Use esta tabela em vez da fórmula.
Combine a VRAM da sua GPU com o maior nível de modelo que ela suporta em Q4 e depois consulte a tabela acima para o modelo exato.
Se você já sabe quanta VRAM sua GPU tem, pule as contas de tamanho de modelo — encontre a VRAM da sua placa na tabela abaixo e use o nível de modelo ao lado dela.
| Nível de VRAM | Melhor modelo (Q4) | GPUs de exemplo | O que cabe |
|---|---|---|---|
| 4 GB | Llama 3.2 3B ou Phi-3.5-mini (~1,5-2 GB) | RTX 3050 4 GB, GTX 1650 | Só classe 3B — modelos 7B vão dar OOM |
| 6 GB | Qwen3 4B, ou Llama 3.1 8B em Q4 agressivo (~3-4 GB) | RTX 2060 6 GB, RTX 3050 Ti | 4B com folga; 8B é apertado |
| 8 GB | Llama 3.1 8B ou Qwen3 8B (~3,5-5 GB) com margem real | RTX 4060 Ti 8 GB, RTX 3070 | O ponto ideal mais comum para 7-8B |
| 12 GB | Qwen3 14B (~6,5 GB), ou 7-8B em Q5/Q8 para mais qualidade | RTX 3060 12 GB, RTX 4070 | 14B com folga, espaço para mais contexto |
| 16 GB | Qwen3 14B em Q5/Q8, ou classe 22B (Gemma, Qwen) em Q4 (~11 GB) | RTX 4060 Ti 16 GB, RTX 4080 | 22B é o teto prático neste nível |
| 24 GB | 22-32B com folga em Q8 completo; 70B só abaixo de 4 bits com perda | RTX 4090, RTX 3090 | 70B precisa de ~42 GB reais — este nível não é suficiente |
| 32 GB | 22-32B em precisão total, ou como uma placa em um setup dual-GPU para 70B | RTX 5090 | Ainda insuficiente para um 70B Q4 sozinho (~42 GB necessários) |
| 48 GB | 70B com folga em Q4 (~42 GB), apertado em Q5 (~50 GB) | 2× RTX 4090, RTX 6000 Ada | Primeiro nível que cabe 70B sem truques de quantização com perda |
| 64 GB+ (memória unificada) | 70B com folga em Q4/Q5, sem precisar de dual-GPU | Mac Studio M5 Max/Ultra (128-256 GB) | Única opção de consumo que cabe 70B sem GPU discreta |
Estes são números-alvo de compra em Q4 com overhead realista incluído — veja a tabela acima para os mínimos de computação puros por nível de quantização. A memória unificada do Apple Silicon (Mac Studio M5 Max/Ultra) é uma alternativa à GPU discreta para os níveis de 48 GB+ — veja Rodar modelos 70B em Apple Silicon M5 Max para os tok/s exatos em cada nível de quantização.
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 ~160-192 GB (40-48 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 (40-48 GB) + cache KV (4 GB) + sistema (2 GB) = ~46-54 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 apenas 24 GB para qualquer modelo 70B. Falso. Q4 precisa de 40-48 GB. Q8 precisa de 70 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?
Não. O Mistral Small é um modelo de 22-24B -- mesmo em Q4 precisa de cerca de 13-14 GB de VRAM só para os pesos. Uma GPU de 6 GB ou 8 GB vai dar erro de OOM. Reserve 16 GB para uma margem confortável, ou use um modelo de 7B-8B para uma placa de 6-8 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?
Sim, com folga. Um modelo 13B precisa de cerca de 8 GB em Q4, então 12 GB deixa margem real. Em Q5 (~9 GB) ainda está confortável; em Q8 (~14 GB) fica apertado.
Preciso de 24 GB para um modelo 70B?
Não. Um modelo 70B precisa de 40-48 GB em Q4. Em Q5+, você precisa de 50 GB+. 24 GB não é suficiente para nenhum modelo 70B em nenhum nível de quantização.
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.
Qual é a fórmula de VRAM para LLMs?
VRAM (GB) = parâmetros do modelo (bilhões) × bytes por parâmetro + overhead. Em Q4 (4 bits): 7B × 0.5 bytes + 1 GB overhead ≈ 4.5 GB de pesos + 2 GB de cache KV = ~7 GB no total.
Quanto mais VRAM o Q8 precisa em relação ao Q4?
O Q8 usa o dobro da VRAM do Q4. Um modelo 7B em Q4 precisa de ~4-5 GB; em Q8, ~8-9 GB. Verifique sempre o nível de quantização antes de comprar uma GPU.
Posso rodar um modelo 70B em duas GPUs?
Sim. Duas RTX 5090 (24 GB cada) combinam 48 GB de VRAM — suficiente para um modelo 70B em Q4. O llama.cpp e o Ollama suportam várias GPUs via paralelismo tensorial e --n-gpu-layers.
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