Calculadora de VRAM

Estime os requisitos de VRAM da GPU para inferência de LLM, ajuste fino completo, treino LoRA e quantização GGUF. Calcule os pesos do modelo, o cache KV, os estados do otimizador e a sobrecarga do framework desde os primeiros princípios e veja quais GPUs cabem na sua carga de trabalho. Grátis, instantâneo e totalmente privado.

VRAM Calculator

Estimate GPU VRAM requirements for LLM inference, full fine-tuning, LoRA training, and GGUF quantisation. Model weights, KV cache, activations, optimizer states, and framework overhead - all calculated from first principles in your browser.

Model Preset

32 layers · 8 KV heads · head dim 128

Model Architecture

Parameters (Billions)

Transformer Layers

KV Heads (GQA)

Head Dimension

Workload Mode

Weights + KV cache + minimal activations. Smallest footprint.

Weight Precision

Context & Batch

Sequence Length

tokens

51264K128K

Batch Size

reqs

13264

Compare Against GPU

Total VRAM Required

16.57 GB

for inference

8.03B params · FP16 · seq 4,096 · batch 1

Model Weights

14.96 GB

KV Cache

512 MB

Activations

31 MB

Overhead

1.08 GB

NVIDIA RTX 4090 (24 GB) (24 GB)

✅ Fits on a single GPU (69.0% VRAM used)

Single GPU ✓

VRAM Usage16.57 GB / 24 GB (69.0%)

On-prem dev/inference, small models

VRAM Breakdown

Model Weights14.96 GB (90.3%)

KV Cache512 MB (3.0%)

Activations31 MB (0.2%)

Framework Overhead1.08 GB (6.5%)

Precision Comparison (Same Config)

Precision	Weights	Total VRAM	Fits 24 GB?
FP32	29.91 GB	33.14 GB	✗ No
FP16 Selected	14.96 GB	16.57 GB	✓ Yes
BF16	14.96 GB	16.57 GB	✓ Yes
FP8	7.48 GB	8.55 GB	✓ Yes
INT8	7.48 GB	8.55 GB	✓ Yes
INT4	3.74 GB	4.54 GB	✓ Yes

GPU Compatibility

GPU	VRAM	GPUs Needed	Status
NVIDIA RTX 4090 (24 GB)Selected On-prem dev/inference, small models	24 GB	1×	Single GPU
NVIDIA A10G (24 GB) Inference & ML serving	24 GB	1×	Single GPU
NVIDIA L4 (24 GB) Cost-efficient inference	24 GB	1×	Single GPU
NVIDIA RTX 3090 (24 GB) Budget on-prem inference	24 GB	1×	Single GPU
Apple M4 Pro (24 GB unified) Mac inference, small models	24 GB	1×	Single GPU
NVIDIA A100 40 GB Training medium models, inference	40 GB	1×	Single GPU
NVIDIA L40S (48 GB) Inference, multi-modal workloads	48 GB	1×	Single GPU
NVIDIA A40 (48 GB) Inference & fine-tuning	48 GB	1×	Single GPU
Apple M4 Max (48 GB unified) Mac inference, light fine-tuning	48 GB	1×	Single GPU
NVIDIA H100 / H100 PCIe (80 GB) LLM training & production inference	80 GB	1×	Single GPU
NVIDIA A100 80 GB LLM fine-tuning & inference	80 GB	1×	Single GPU
AMD MI250X (128 GB) Large-scale HPC & LLM training	128 GB	1×	Single GPU
Apple M4 Ultra (128 GB unified) On-device Mac inference	128 GB	1×	Single GPU
NVIDIA H200 SXM (141 GB) Largest LLM inference & training	141 GB	1×	Single GPU
AMD MI300X (192 GB) Very large model inference & training	192 GB	1×	Single GPU
NVIDIA RTX 3080 (10 GB) Small model inference only	10 GB	2×	2× Multi-GPU
NVIDIA RTX 4070 (12 GB) Light inference, LoRA tuning	12 GB	2×	2× Multi-GPU
NVIDIA V100 (16 GB) Legacy workloads	16 GB	2×	2× Multi-GPU
NVIDIA RTX 4080 (16 GB) Consumer dev, small inference	16 GB	2×	2× Multi-GPU

Estimation Notes: VRAM estimates use the standard formula: weights × bytes/param + KV cache (2 × layers × KV-heads × head-dim × seq-len × batch × FP16 bytes) + framework overhead (7%). Training estimates include Adam optimizer states and gradients. Actual usage varies by runtime (vLLM, llama.cpp, Transformers), quantisation method, and model architecture specifics. Always leave 10-15% VRAM headroom. All calculations run locally in your browser.

Por que usar nossa calculadora de VRAM

Planejar hardware para LLM sem medir a memória da GPU costuma resultar em placas superdimensionadas ou em erros de memória insuficiente (OOM) durante a execução. Esta calculadora aplica a fórmula real de VRAM em vez de regras aproximadas, para dimensionar suas GPUs com confiança antes de alugar ou comprar.

Escolha entre os modos de inferência, ajuste fino completo, treino LoRA e quantização GGUF: cada modo aplica a fórmula correta para essa carga de trabalho e atualiza na hora os pesos, o cache KV, os estados do otimizador e a sobrecarga do framework.

Cálculos desde os primeiros princípios: pesos, cache KV, ativações, estados do otimizador, gradientes e sobrecarga do framework, sem chutes.
Totalmente privado: suas configurações são calculadas no navegador e nunca enviadas a servidores.
Modos de inferência, ajuste fino, LoRA e GGUF, cada um com sua fórmula de VRAM específica.
Tabela de compatibilidade com 19 GPUs, incluindo H100, A100, RTX 4090, AMD MI300X e Apple Silicon.

Casos de uso comuns

Da escolha do hardware ao planejamento de treinos, estes são os cenários em que uma estimativa confiável de VRAM economiza tempo e dinheiro.

Escolher uma GPU para inferência de LLM: verificar se um modelo de 70B cabe em uma única A100 de 80 GB ou exige duas GPUs.
Planejar treinos de ajuste fino: o ajuste completo com Adam costuma exigir de 3 a 6 vezes a memória da inferência.
Otimizar o cache KV para contextos longos: ver quanta VRAM extra o contexto consome ao ir de 4K para 32K ou 128K tokens.
Escolher a quantização GGUF certa: comparar Q4, Q5 e Q8 e o equilíbrio entre qualidade e memória.
Rodar modelos em hardware de consumidor: saber quais modelos quantizados cabem em 12, 16 ou 24 GB de VRAM.
Planejar o orçamento de treino LoRA: ver como o rank escolhido afeta a memória necessária.

Como a VRAM é calculada e quais são os limites

A VRAM é a memória da placa de vídeo, não a RAM do sistema: pesos, cache KV, ativações e buffers do framework precisam caber ao mesmo tempo nesse orçamento fixo. A quantidade necessária depende do número de parâmetros, da precisão numérica, do comprimento da sequência e do tamanho do lote, além do tipo de carga de trabalho (inferência, treino ou LoRA). Usamos as mesmas fórmulas que vLLM, Transformers e llama.cpp aplicam internamente.

A calculadora fornece estimativas de nível de engenharia, não medições exatas: o uso real pode variar de ±10-20 % conforme o runtime, a implementação do modelo, a captura de grafos CUDA e a fragmentação de memória. Todos os cálculos rodam localmente no seu navegador.

Informe os parâmetros do modelo e a precisão: um modelo de 7B em FP16 pesa ~14 GB e ~3,5 GB em INT4.
Some o cache KV a partir de camadas, cabeças KV, dimensão da cabeça, comprimento da sequência e lote; o GQA o reduz bastante.
Para treino, some gradientes e estados do otimizador Adam: cerca de 12 bytes extras por parâmetro no ajuste fino completo.
Adicione a sobrecarga do framework: reservamos 7 % para PyTorch, CUDA e fragmentação de memória.

Perguntas frequentes

Uma calculadora de VRAM estima a memória de GPU necessária para carregar e executar um modelo de linguagem grande. Calcula o armazenamento dos pesos do modelo (parâmetros × bytes por precisão), o cache KV (a partir do comprimento da sequência, do tamanho do lote e da arquitetura de atenção), as ativações e, para treino, os estados do otimizador e os gradientes. Funciona por completo no navegador, sem enviar dados.

O número de parâmetros costuma estar no nome do modelo (7B, 70B, 405B). Para valores exatos, consulte o arquivo config.json do modelo no Hugging Face e procure o campo "num_parameters". Nossos presets incluem contagens precisas de parâmetros para modelos populares como Llama 3.1, Qwen2.5, Mistral e Gemma 2.

No ajuste fino completo, a GPU precisa armazenar os pesos do modelo, tensores de gradiente do mesmo tamanho e o estado do otimizador Adam (primeiro momento, segundo momento e pesos mestres em FP32), o que adiciona cerca de 12 bytes por parâmetro. Para um modelo de 7B em BF16, a inferência exige ~14 GB, mas o treino completo precisa de ~60-80 GB.

O cache KV armazena as chaves e valores de atenção de todos os tokens anteriores. Seu tamanho = 2 × camadas × cabeças KV × dimensão da cabeça × comprimento da sequência × tamanho do lote × bytes. Cresce linearmente com o contexto: passar de 4K para 128K tokens o multiplica por 32. O GQA reduz as cabeças KV e diminui bastante seu tamanho.

O modo GGUF calcula a memória dos pesos como parâmetros × (bits de quantização / 8) bytes. O cache KV é sempre armazenado em FP16, independentemente da quantização dos pesos. O Q4_K_M (≈4 bits) é o equilíbrio mais popular entre qualidade e eficiência de memória para usuários de llama.cpp e Ollama.

O GQA reduz o número de cabeças de chave e valor a uma fração das cabeças de consulta. Como o cache KV escala com as cabeças KV, o GQA pode reduzi-lo em 4 vezes ou mais. O Llama 3.1 usa 8 cabeças KV contra 32 cabeças de consulta. Informe num_key_value_heads do config.json para estimativas precisas.

Em FP16, um modelo de 70B exige aproximadamente 140 GB só para os pesos, cabendo em duas placas H100 de 80 GB. Em INT4, os pesos caem para ~35 GB e cabem em uma única H100. A tabela de compatibilidade de GPU mostra o número mínimo de GPUs para cada placa da sua configuração.

A calculadora usa a fórmula teórica padrão na qual todos os runtimes se baseiam. A atenção paginada do vLLM pode adicionar 5-15 % de sobrecarga. O llama.cpp mapeia os pesos em memória e consegue rodar modelos maiores. A margem de 7 % cobre a maior parte da variação entre runtimes. Valide sempre com um teste pequeno antes de implantar em produção.

Sim. A calculadora de VRAM roda inteiramente no seu navegador. Parâmetros de arquitetura, precisões e ajustes de contexto são processados localmente no seu dispositivo e nunca enviados a servidores. Não é preciso conta nem cadastro.