Pular para o conteúdo
LLM Pricing Calc
Preços de aluguel de GPU

Calculadora de VRAM para LLM: Quanta Memória de GPU Você Precisa?

Confira os requisitos de hardware para rodar um LLM local: a memória dividida em pesos, KV cache e overhead, e quais GPUs de consumo, Macs e GPUs na nuvem conseguem rodá-lo.

Quantização
Tamanho do contexto
KV cache

VRAM total necessária

49.1 GB

Llama 3.3 70B Instruct · Q4_K_M · contexto de 8K · 1 usuário

KV cache: 320 KB / token

Pesos do modelo
42.8 GB
KV cache
2.68 GB
Overhead do runtime
3.57 GB
Compatibilidade de hardware
HardwareMemória utilizávelCabe?Velocidade est.Nuvem $/h
RTX 4060 Ti 16GBGPU de consumo16 GBPrecisa de 4×~17 tok/s—
RTX 3090 24GBGPU de consumo24 GBPrecisa de 3×~43 tok/s$0.66
RTX 4090 24GBGPU de consumo24 GBPrecisa de 3×~46 tok/s$1.02
RTX 5090 32GBGPU de consumo32 GBPrecisa de 2×~54 tok/s$1.38
MacBook Pro M4 Max 64GBApple Silicon48 GBNão cabe——
MacBook Pro M4 Max 128GBApple Silicon96 GBCabe~8 tok/s—
Mac Studio M3 Ultra 512GBApple Silicon384 GBCabe~12 tok/s—
NVIDIA L4 24GBGPU na nuvem24 GBPrecisa de 3×~14 tok/s$1.32
NVIDIA L40S 48GBGPU na nuvem48 GBPrecisa de 2×~26 tok/s$1.72
NVIDIA A100 80GBGPU na nuvem80 GBCabe~31 tok/s$1.39
NVIDIA H100 80GBGPU na nuvem80 GBCabe~51 tok/s$2.39
NVIDIA H200 141GBGPU na nuvem141 GBCabe~73 tok/s$3.29
NVIDIA B200 180GBGPU na nuvem180 GBCabe~121 tok/s$5.49
AMD MI300X 192GBGPU na nuvem192 GBCabe~80 tok/s$2.49

VRAM e largura de banda de memória são especificações do fabricante. Os preços por hora são as tarifas on-demand do RunPod Community Cloud; outros provedores e regiões variam. A memória utilizável do Apple Silicon considera o limite padrão de memória fixada para a GPU no macOS (~75% da memória unificada). "Precisa de N×" significa tensor parallelism em N GPUs idênticas. Preços de GPU: Preços oficiais ↗

Guia

Quanta VRAM você precisa para rodar um LLM?

É a memória da GPU, e não o poder de processamento, que decide se um modelo vai rodar localmente ou não. Se o modelo não cabe na VRAM, o llama.cpp e o Ollama jogam camadas para a RAM do sistema e a geração cai de dezenas de tokens por segundo para uma lentidão extrema. A VRAM total tem três partes:

  • Pesos = parâmetros × bits por peso ÷ 8. O Q4_K_M tem em média ~4,85 bits, o Q8_0 ~8,5 bits e o FP16 16 bits.
  • KV cache = 2 × camadas × KV heads × head dim × contexto × usuários × bytes por valor. A multi-head latent attention do DeepSeek armazena, em vez disso, um único latente comprimido de 576 dimensões por camada, então o cache dele é bem menor.
  • Overhead ≈ 1 GB de contexto CUDA/Metal + ~6% dos pesos para ativações e buffers temporários, mais um pouco por usuário adicional.

Pesos do modelo e quantização: Q4 vs Q8 vs FP16

Os pesos são o custo fixo. Todo parâmetro precisa ficar na memória, então o tamanho do modelo em bilhões de parâmetros define o piso. A quantização reduz cada parâmetro de 16 bits para 8 ou cerca de 4, trocando um pouco de precisão por um consumo de memória muito menor. Veja o que isso significa para dois modelos Llama populares com contexto de 8K:

VRAM por quantização do Llama 3.1 8B Instruct e do Llama 3.3 70B Instruct com contexto de 8K
QuantizaçãoLlama 3.1 8B InstructLlama 3.3 70B Instruct
Q4_K_M (4 bits)7.21 GB49.1 GB
Q8_0 / FP8 (8 bits)11.1 GB83.2 GB
FP16 / BF16 (16 bits)19.0 GB153.4 GB

Q4_K_M é o padrão para inferência local com Ollama e LM Studio: cerca de 70% menor que o FP16, com uma perda de qualidade que a maioria das pessoas nunca percebe em chat. Q8_0 é praticamente sem perdas e uma boa escolha quando você tem memória sobrando. FP16/BF16 é o que servidores de produção como o vLLM rodam por padrão, e é a base para fine-tuning. Abaixo de cerca de 3 bits por peso, a qualidade cai rapidamente, então um modelo menor em Q4 costuma ser melhor que um maior espremido em Q2.

Crescimento do KV cache com o tamanho do contexto

O KV cache é o custo variável, e é ele que pega as pessoas de surpresa. Ele armazena as keys e values de atenção de cada token da janela de contexto, então cresce linearmente com o tamanho do contexto e com o número de usuários simultâneos. Para o Llama 3.3 70B Instruct em Q4, o KV cache ocupa 2.68 GB com contexto de 8K, 42.9 GB com 128K e 171.8 GB se quatro usuários mantiverem 128K de contexto cada. Um modelo que cabe com folga em 8K pode ficar sem memória com contexto longo. Quantizar o KV cache para 8 bits (a opção "KV cache" acima) reduz o tamanho dele pela metade, com pouco impacto na qualidade na maioria das cargas de trabalho.

Dimensionamento de GPU: consumo vs nuvem

GPUs de consumo (RTX 4060 Ti 16 GB, RTX 3090/4090 24 GB, RTX 5090 32 GB) rodam modelos de 7B–14B em Q8, e as placas de 24–32 GB aguentam modelos da classe de 30B em Q4. O Llama 3.3 70B Instruct em Q4 precisa de cerca de 49.1 GB, ou 3× RTX 4090. O Apple Silicon troca velocidade por capacidade: um Mac com 128 GB ou mais consegue carregar modelos da classe de 70B e modelos mixture-of-experts de porte médio que nenhuma GPU de consumo sozinha consegue comportar, com menos tokens por segundo porque a memória unificada tem menos largura de banda que GDDR ou HBM. GPUs na nuvem como a L40S (48 GB), a A100 e a H100 (80 GB) e a H200 (141 GB) são a escolha certa para servir em FP16, contextos longos e muitos usuários simultâneos, quando é o KV cache, e não os pesos, que domina a memória.

Deixe 10–15% de folga em vez de ocupar a VRAM até o último gigabyte; drivers, a tela e a fragmentação também consomem uma parte. Se você está dimensionando um LLM self-hosted para produção, e não para um setup de hobby, a próxima pergunta é o custo: a calculadora de API de LLM vs self-hosting compara uma GPU alugada com o preço por token, e a calculadora de preço de LLM mostra quanto a mesma carga de trabalho custa em APIs hospedadas. Os preços hospedados de modelos open-weight como Llama, Qwen e DeepSeek estão na tabela de preços de LLMs.

Mais ferramentas de custo de IA

Perguntas frequentes sobre VRAM para LLM

Quanta VRAM o Llama 3.3 70B Instruct precisa?

Em Q4_K_M com contexto de 8K, o Llama 3.3 70B Instruct precisa de cerca de 49.1 GB no total: 42.8 GB de pesos, 2.68 GB de KV cache e 3.57 GB de overhead. Isso é mais do que qualquer GPU de consumo sozinha: ele cabe em uma NVIDIA A100 80GB, NVIDIA H100 80GB, NVIDIA H200 141GB, NVIDIA B200 180GB ou AMD MI300X 192GB, ou em um MacBook Pro M4 Max 128GB ou Mac Studio M3 Ultra 512GB, ou em 3× RTX 4090 divididas com tensor parallelism. Em FP16, ele precisa de cerca de 153.4 GB, o que exige 3× H100 80GB.

Quanta VRAM eu preciso para rodar um LLM?

Aproximadamente: parâmetros (bilhões) × bits por peso ÷ 8 = GB para os pesos. Some o KV cache, que cresce com o tamanho do contexto e o número de usuários simultâneos, mais 1–2 GB de overhead do runtime. Um modelo de 70B em Q4_K_M precisa de cerca de 43 GB só para os pesos, então não cabe em uma única RTX 4090 de 24 GB.

O que é o KV cache e por que ele importa?

O KV cache armazena as keys e values de atenção de cada token do contexto para que não precisem ser recalculados. O tamanho dele = 2 × camadas × KV heads × dimensão do head × tamanho do contexto × bytes por valor × usuários. Com 128K de contexto, ele pode ficar maior que os próprios pesos do modelo, e é por isso que a inferência com contexto longo muitas vezes fica sem memória.

Qual quantização devo usar?

Q4_K_M é a escolha mais popular para inferência local: cerca de 70% menor que o FP16, com uma pequena perda de qualidade. Q8_0 é praticamente sem perdas com metade do tamanho do FP16. FP16/BF16 é a precisão original usada pela maioria das stacks de serving em produção, como o vLLM.

Modelos MoE precisam de menos VRAM?

Não. Modelos mixture-of-experts como o Qwen3-235B-A22B ou o gpt-oss-120b precisam manter todos os experts na memória, então a VRAM depende do total de parâmetros. Só a velocidade se beneficia do número menor de parâmetros ativos, porque menos pesos são lidos por token.

Quanto da memória unificada de um Mac a GPU pode usar?

Por padrão, o macOS permite que a GPU fixe cerca de 65–75% da memória unificada. Esta calculadora considera 75% (48 GB em um MacBook Pro de 64 GB, 96 GB em um de 128 GB). Você pode aumentar o limite com sudo sysctl iogpu.wired_limit_mb, por sua conta e risco.

É a mesma VRAM que o Ollama e o llama.cpp usam?

Bem próximo. O Ollama e o llama.cpp carregam arquivos GGUF, cujo tamanho corresponde ao valor dos pesos mostrado aqui para a mesma quantização. O Ollama também aloca o KV cache para o contexto inteiro definido em num_ctx, e cópias extras quando atende requisições em paralelo, então ajuste os campos de contexto e usuários conforme as configurações do seu Ollama. Se o total passar da sua VRAM, o Ollama joga camadas para a RAM do sistema e a geração fica bem mais lenta.

Qual a precisão da estimativa de tokens por segundo?

É uma estimativa baseada na largura de banda de memória para um único usuário: largura de banda × ~65% de eficiência ÷ bytes de pesos ativos lidos por token. A velocidade real depende do motor de inferência, do tamanho do batch e de o modelo estar dividido entre GPUs ou não. Use como uma ordem de grandeza.