Calculadora de VRAM de GPU
Estime a VRAM de GPU necessária para executar ou treinar um transformer / modelo de linguagem grande (LLM). Informe o número de parâmetros, a precisão (fp16, int8, int4…), o tamanho do contexto e o tamanho do lote para ver a divisão entre pesos, cache KV, ativações, gradientes e estado do otimizador, e verifique em quais GPUs o modelo cabe.
Entrada
Escolha um modelo conhecido para preencher parâmetros, dimensão oculta e camadas, ou escolha Personalizado.
Total de parâmetros do modelo em bilhões (7 para um modelo de 7B).
Número de camadas do transformer.
Tokens por sequência (comprimento do contexto).
Saída
| Componente | Memória | Participação |
|---|---|---|
| No data yet | ||
| GPU | VRAM | Compatibilidade | GPUs necessárias |
|---|---|---|---|
| No data yet | |||
Mais formas de usar esta ferramenta
API REST
curl -X POST https://api.iotools.cloud/v1/tool/gpu-vram-calculator \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"modelPreset": "mistral-7b",
"mode": "inference",
"precision": "fp16",
"batchSize": "1",
"seqLen": "4096"
}'Troque pela sua própria chave, da sua conta. Os campos da ferramenta viram o corpo da requisição — sem envelope.
Peça a um agente de IA
Use the IOTools `gpu-vram-calculator` tool (GPU VRAM Calculator) on this input:
YOUR_INPUT_HERECole isto em qualquer agente conectado ao servidor MCP do IOTools e depois adicione sua entrada.
Widget para incorporar
<iframe
src="https://iotools.cloud/embed/gpu-vram-calculator/"
width="100%" height="520" frameborder="0" scrolling="no" loading="lazy"
title="Calculadora de VRAM de GPU — iotools.cloud"
sandbox="allow-scripts allow-forms allow-same-origin allow-downloads allow-popups allow-popups-to-escape-sandbox"
allow="clipboard-write"
style="width:100%;border:1px solid #e5e7eb;border-radius:12px;overflow:hidden"></iframe>
<script src="https://iotools.cloud/embed.js" async></script>Coloque isso na sua própria página — grátis, sem chave, só um link de volta.
| Custo por chamada de API/MCP | A partir de 5 créditos |
|---|---|
| Precisa de mais créditos? | Ver preços |
Também disponível via
Guias
A Calculadora de VRAM de GPU estima quanta memória de vídeo um transformer ou modelo de linguagem grande precisa para rodar — tanto para inferência quanto para treinamento — para que você saiba em segundos se um modelo cabe na sua GPU antes de alugar, comprar ou baixar qualquer coisa.
Informe a quantidade de parâmetros (ou escolha uma predefinição, como Mistral 7B ou Llama 3 70B), escolha a precisão e defina o tamanho do contexto e do lote. A ferramenta divide o total em cada componente que consome VRAM e compara o resultado com várias GPUs comuns.
Como a VRAM é calculada
Os tamanhos de memória são informados em GiB (base‑1024) — a mesma unidade que o nvidia-smi mostra.
A inferência precisa de três coisas na memória:
- Pesos do modelo —
parâmetros × bytes por parâmetro. A precisão define os bytes: fp32 = 4, fp16/bf16 = 2, int8 = 1, int4 = 0,5. Um modelo de 7 bilhões de parâmetros em fp16 ocupa7B × 2 = 14 GBde pesos. - Cache KV — as chaves e valores de atenção armazenados para cada token:
2 × lote × comprimento da sequência × dimensão oculta × camadas × 2 bytes. Ele cresce com o comprimento do contexto, e é por isso que a inferência de contexto longo pode precisar de muito mais memória do que apenas os pesos. Modelos quantizados (int8/int4) continuam mantendo o cache KV em fp16. - Ativações e ~10% de overhead do framework — buffers temporários, além do contexto CUDA e da fragmentação do alocador.
O treinamento é bem mais pesado porque também armazena:
- Gradientes — um valor por parâmetro.
- Estado do otimizador — o Adam/AdamW mantém momento e variância em fp32, 8 bytes por parâmetro; SGD com momento usa 4; SGD puro usa 0.
- Pesos mestres em fp32 — mantidos no treinamento de precisão mista (+4 bytes por parâmetro).
- Ativações — o maior custo do treinamento, reduzido pelo checkpointing de gradiente (recalcular as ativações no passo de retropropagação) ao custo de mais computação.
Por isso, o fine‑tuning completo de um modelo de 7B com Adam precisa de cerca de 16–20 bytes por parâmetro — mais de 100 GB — enquanto rodar o mesmo modelo para inferência em fp16 precisa de apenas cerca de 15 GB.
Dicas para fazer um modelo caber
- Quantize. Passar de fp16 para int4 reduz a memória dos pesos em 4×, transformando um modelo de 70B de cerca de 140 GB para cerca de 35 GB.
- Encurte o contexto. O cache KV escala linearmente com o comprimento da sequência e com o tamanho do lote.
- Use LoRA / QLoRA para o fine‑tuning, evitando armazenar gradientes completos e estado de otimizador para cada peso.
Estes números são exatos?
Não — trate-os como uma base para planejamento. O uso real depende do framework, da implementação de atenção (o FlashAttention reduz a memória de ativações), do paralelismo de tensores e do comportamento do alocador. As estimativas são calculadas inteiramente no seu navegador; nada é enviado.