/* ── Base ── */
*, *::before, *::after { box-sizing: border-box; }
:root {
–orange: #F47721;
–orange-lt: #FF9A45;
–dark: #0F1117;
–text: #1A1D2E;
–text2: #4A5070;
–card: #F8F9FC;
–border:#D8DCE8;
–green: #1A7F4B;
–yellow:#8B6A00;
–red: #B91C1C;
–blue: #1D4ED8;
–radius:8px;
–font: -apple-system, BlinkMacSystemFont, “Segoe UI”, system-ui, sans-serif;
–mono: “SF Mono”, “Fira Code”, Menlo, Consolas, monospace;
}
body { font-family: var(–font); color: var(–text); line-height: 1.65; max-width: 780px; margin: 0 auto; padding: 0 20px 80px; }

/* Typography */
h1 { font-size: 2rem; font-weight: 800; line-height: 1.2; margin: 0 0 .5rem; text-wrap: balance; }
h2 { font-size: 1.3rem; font-weight: 700; margin: 2.5rem 0 .75rem; padding-top: .25rem; line-height: 1.3; }
h3 { font-size: 1.05rem; font-weight: 700; margin: 1.75rem 0 .5rem; color: var(–text); }
p { margin: 0 0 1rem; }
ul, ol { margin: 0 0 1rem; padding-left: 1.4rem; }
li { margin-bottom: .4rem; }
strong { font-weight: 700; }
code { font-family: var(–mono); font-size: .85em; background: #EEF0F8; padding: 1px 5px; border-radius: 3px; }
a { color: var(–orange); text-decoration: none; }
a:hover { text-decoration: underline; }

/* Breadcrumb */
.breadcrumb { font-size: .78rem; color: var(–text2); margin-bottom: 1.5rem; }
.breadcrumb a { color: var(–text2); }
.breadcrumb span { margin: 0 .4rem; }

/* Meta */
.meta-bar { display: flex; gap: 16px; flex-wrap: wrap; align-items: center; font-size: .78rem; color: var(–text2); margin-bottom: 2rem; padding-bottom: 1rem; border-bottom: 1px solid var(–border); }
.meta-bar .author { font-weight: 600; color: var(–text); }

/* Lead / chapeau */
.lead { font-size: 1.1rem; color: var(–text2); line-height: 1.65; margin-bottom: 1.5rem; }

/* CTA box */
.cta-box {
background: linear-gradient(135deg, #FFF3E8 0%, #FFF8F0 100%);
border: 1px solid rgba(244,119,33,.3); border-left: 4px solid var(–orange);
border-radius: var(–radius); padding: 18px 20px; margin: 2rem 0;
}
.cta-box p { margin: 0 0 .5rem; font-size: .9rem; }
.cta-box p:last-child { margin: 0; }
.cta-btn {
display: inline-block; background: var(–orange); color: #fff;
padding: 10px 20px; border-radius: 6px; font-weight: 700; font-size: .88rem;
text-decoration: none; margin-top: 10px;
}
.cta-btn:hover { background: #D96A1E; text-decoration: none; }

/* TOC */
.toc {
background: var(–card); border: 1px solid var(–border);
border-radius: var(–radius); padding: 18px 22px; margin: 2rem 0;
}
.toc h2 { margin: 0 0 .75rem; font-size: 1rem; }
.toc ol { margin: 0; padding-left: 1.2rem; }
.toc li { margin-bottom: .3rem; font-size: .88rem; }
.toc a { color: var(–text2); }

/* Tables */
.tbl-wrap { overflow-x: auto; margin: 1.5rem 0; border-radius: var(–radius); border: 1px solid var(–border); }
table { width: 100%; border-collapse: collapse; font-size: .85rem; }
th { background: #EEF0F8; padding: 9px 12px; text-align: left; font-weight: 700; font-size: .78rem; text-transform: uppercase; letter-spacing: .04em; color: var(–text2); border-bottom: 1px solid var(–border); white-space: nowrap; }
td { padding: 9px 12px; border-bottom: 1px solid var(–border); vertical-align: top; }
tbody tr:last-child td { border-bottom: none; }
tbody tr:nth-child(even) td { background: #FAFBFE; }
td.num { font-variant-numeric: tabular-nums; text-align: right; font-family: var(–mono); font-size: .82rem; }
.ok { color: var(–green); font-weight: 700; }
.warn { color: var(–yellow); font-weight: 700; }
.no { color: var(–red); font-weight: 700; }

/* Callouts */
.note {
padding: 13px 16px; border-radius: var(–radius); margin: 1.5rem 0;
display: flex; gap: 10px; align-items: flex-start; font-size: .88rem; line-height: 1.55;
}
.note-warn { background: #FFFBEB; border-left: 4px solid #D97706; }
.note-info { background: #EFF6FF; border-left: 4px solid #3B82F6; }
.note-tech { background: #F0FDF4; border-left: 4px solid #16A34A; }
.note span:first-child { font-size: 1.1rem; flex-shrink: 0; }
.note p { margin: 0; }

/* Checklist */
.checklist { list-style: none; padding: 0; }
.checklist li { padding: .4rem 0 .4rem 1.8rem; position: relative; border-bottom: 1px solid var(–border); font-size: .9rem; }
.checklist li::before { content: “✓”; position: absolute; left: 0; color: var(–green); font-weight: 700; }
.checklist li:last-child { border-bottom: none; }

/* Formula box */
.formula {
background: #F0F4FF; border: 1px solid #C7D2FE;
border-radius: var(–radius); padding: 14px 18px; margin: 1.5rem 0;
font-family: var(–mono); font-size: .9rem; line-height: 1.8;
}
.formula .label { font-family: var(–font); font-size: .78rem; text-transform: uppercase; letter-spacing: .06em; color: var(–text2); font-weight: 700; margin-bottom: 8px; display: block; }

/* Scenario cards */
.scenario-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: 14px; margin: 1.5rem 0; }
.scenario-card { background: var(–card); border: 1px solid var(–border); border-radius: var(–radius); padding: 14px 16px; }
.scenario-card .name { font-weight: 700; font-size: .9rem; color: var(–text); margin-bottom: 8px; border-bottom: 1px solid var(–border); padding-bottom: 6px; }
.scenario-card .row { display: flex; justify-content: space-between; font-size: .8rem; padding: 3px 0; color: var(–text2); }
.scenario-card .row strong { color: var(–text); }
.scenario-card .gpu-rec { margin-top: 8px; padding: 5px 10px; background: rgba(244,119,33,.1); border-radius: 4px; font-size: .8rem; font-weight: 700; color: var(–orange); text-align: center; }

/* FAQ */
.faq { margin: 1.5rem 0; }
.faq-item { border-bottom: 1px solid var(–border); }
.faq-q { font-weight: 700; font-size: .95rem; padding: 14px 0 10px; color: var(–text); cursor: pointer; display: flex; justify-content: space-between; align-items: center; }
.faq-q::after { content: “+”; font-size: 1.2rem; color: var(–orange); flex-shrink: 0; }
.faq-item.open .faq-q::after { content: “−”; }
.faq-a { display: none; font-size: .88rem; color: var(–text2); padding-bottom: 14px; line-height: 1.6; }
.faq-item.open .faq-a { display: block; }

/* Section divider */
.divider { border: none; border-top: 1px solid var(–border); margin: 2rem 0; }

/* Source note */
.source { font-size: .72rem; color: var(–text2); margin-top: -.5rem; margin-bottom: 1rem; }

/* Related */
.related-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; margin: 1.5rem 0; }
.related-card { border: 1px solid var(–border); border-radius: var(–radius); padding: 12px 14px; }
.related-card a { font-weight: 600; font-size: .9rem; color: var(–text); display: block; margin-bottom: 4px; }
.related-card span { font-size: .78rem; color: var(–text2); }

@media (max-width: 600px) {
h1 { font-size: 1.5rem; }
.related-grid { grid-template-columns: 1fr; }
.scenario-grid { grid-template-columns: 1fr; }
}

/* Dark mode */
@media (prefers-color-scheme: dark) {
:root:not([data-theme=”light”]) {
–text: #E8ECF5; –text2: #9AA0BC; –card: #1C2030;
–border: #2A2F45; –dark: #0F1117;
}
body { background: #0F1117; }
code { background: #22273A; }
th { background: #1C2030; }
tbody tr:nth-child(even) td { background: rgba(255,255,255,.02); }
.toc { background: #1C2030; }
.note-warn { background: #2D2000; }
.note-info { background: #0A1628; }
.note-tech { background: #0A1F12; }
.formula { background: #0D1530; border-color: #2A3A6A; }
.scenario-card { background: #1C2030; }
.related-card { background: #1C2030; }
.cta-box { background: linear-gradient(135deg, #2D1A08 0%, #3D2410 100%); }
}
[data-theme=”light”] body { background: #fff; }
[data-theme=”dark”] body { background: #0F1117; }

Como dimensionar GPU para inferência de modelos de IA

Inferência é o uso real do modelo: cada resposta gerada, cada embedding calculado, cada classificação feita. O dimensionamento correto da GPU define se a aplicação responde em menos de um segundo ou trava sob carga. Esta página explica como calcular VRAM, contexto, KV cache, usuários simultâneos e throughput — sem inventar benchmarks.

1. O que é inferência de IA

Inferência é a etapa em que um modelo treinado executa predições sobre dados novos. Em LLMs (modelos de linguagem de grande porte), cada vez que um usuário envia uma mensagem e recebe uma resposta, o modelo está executando inferência. Em visão computacional, é o momento em que uma imagem é classificada ou um objeto é detectado.

Do ponto de vista de infraestrutura, inferência é diferente do treinamento em três aspectos críticos:

• Carga imprevisível: o treinamento tem carga constante e previsível; a inferência depende do comportamento dos usuários.
• Latência importa: usuários esperam resposta em milissegundos a poucos segundos; o treinamento pode durar horas.
• Modelo fixo em execução: os pesos do modelo ficam carregados na VRAM o tempo todo; isso define o piso de memória independentemente da carga.

2. Modelo e número de parâmetros

O primeiro fator que determina a GPU necessária é o modelo escolhido — especificamente o número de parâmetros. Parâmetros são os pesos aprendidos durante o treinamento. Cada parâmetro ocupa espaço na VRAM quando o modelo é carregado.

Modelos comuns em inferência corporativa (agosto de 2026):

Fonte: repositórios oficiais Hugging Face e Meta AI Research, consultados em agosto de 2026.

3. Quantização e impacto na VRAM

Quantização reduz a precisão numérica dos pesos do modelo, diminuindo o espaço em VRAM e, em geral, aumentando o throughput por unidade de memória. A perda de qualidade varia conforme o método e o modelo.

Referência: documentação llama.cpp (GGUF quantization), Hugging Face Transformers (bitsandbytes), GPTQ. Valores são estimativas — o modelo específico pode variar ±10%.

4. Como calcular a VRAM necessária

A VRAM total em uma configuração de inferência tem três componentes:

Exemplo prático para Llama 3.1 8B em FP16:

Estimativa baseada em documentação vLLM e observações públicas da comunidade. Não constitui benchmark oficial.

Conclusão: uma GPU de 16 GB (como a NVIDIA T4) não suporta Llama 3.1 8B em FP16 com folga de KV cache. Seria necessária uma GPU de 24 GB (L4) ou quantização para INT8.

5. Contexto e KV cache

O KV cache (Key-Value cache) armazena os estados de atenção de todos os tokens já processados na conversa. Quanto maior o contexto suportado e mais usuários simultâneos, mais VRAM é consumida pelo KV cache — mesmo que o modelo em si não mude.

Por que o KV cache importa

Em modelos transformer, cada token gerado precisa “ver” todos os tokens anteriores da conversa. O KV cache evita recalcular esses estados a cada novo token. Sem ele, o custo computacional cresceria quadraticamente com o comprimento da conversa. Com ele, cresce linearmente — mas em memória.

Parâmetros baseados em documentação oficial Llama 3 (Meta AI, 2024). Cálculo é estimativa — frameworks modernos como vLLM usam PagedAttention para gerenciar KV cache de forma mais eficiente.

6. Usuários simultâneos e batch

O número de usuários simultâneos é a variável que mais impacta os requisitos de VRAM além dos pesos do modelo. Cada usuário com uma conversa ativa mantém seu próprio KV cache na memória.

Concorrência vs. batch

Usuários simultâneos são sessões ativas ao mesmo tempo — cada uma com seu próprio contexto e KV cache. Batch é o agrupamento de múltiplas requisições em uma única passagem pela GPU para aumentar eficiência.

¹ Estimativa para Llama 3.1 8B em FP16 com vLLM. Valores reais dependem do modelo específico e da implementação.

7. Tokens por segundo e latência

Throughput e latência são métricas opostas que precisam ser balanceadas. GPUs com maior largura de banda de memória entregam mais tokens por segundo; frameworks com continuous batching reduzem tempo ocioso.

Métricas principais

Largura de banda de memória e throughput

Em inferência de LLMs com batch pequeno, o gargalo é quase sempre a largura de banda de memória (GB/s), não o poder de computação FLOPS. Isso explica por que uma GPU com memória HBM (como A100/H100) entrega mais throughput em inferência do que uma GPU com mais TFLOPS mas memória GDDR6 com menor banda.

8. CPU, RAM e storage

A GPU é o componente central, mas não é suficiente sozinha. Os demais componentes do servidor influenciam o desempenho da inferência de formas específicas.

CPU

Em inferência com LLMs, a CPU não executa o modelo — a GPU faz isso. A CPU gerencia a fila de requisições, o pré-processamento (tokenização), o pós-processamento (decodificação) e a comunicação de rede. Para a maioria dos cenários, um CPU moderno de 16–32 núcleos é suficiente. Cenários com alta taxa de requisições por segundo (RPS) ou uso de múltiplos modelos em paralelo podem exigir mais núcleos.

RAM (sistema)

A RAM do sistema não é usada para os pesos do modelo em inferência normal — esses ficam na VRAM. A RAM é necessária para:

• Sistema operacional e frameworks (~4–8 GB base);
• Buffers de I/O para streaming de respostas;
• Modelos de embedding ou reranking que rodam em CPU;
• Offloading parcial em cenários de restrição severa de VRAM (com impacto severo em throughput).

Recomendação mínima: 2× a VRAM total da GPU. Exemplo: servidor com GPU de 48 GB → ao menos 96 GB de RAM do sistema.

Storage

O storage não impacta o throughput de inferência em execução, mas impacta o tempo de carregamento do modelo. Um modelo de 70B em BF16 (~140 GB) carregado de um SSD NVMe PCIe 4.0 (6 GB/s) leva cerca de 23 segundos. Em um HDD, o mesmo processo levaria vários minutos — inaceitável para reinicializações frequentes.

9. Uma GPU maior ou múltiplas GPUs menores

Quando o modelo não cabe em uma única GPU, existem duas abordagens: distribuir o modelo entre múltiplas GPUs (tensor parallelism ou pipeline parallelism) ou escolher uma GPU com VRAM suficiente.

Quando uma GPU maior é melhor

• Menor complexidade operacional — sem NVLink ou rede de alta velocidade entre GPUs;
• Menor latência — sem overhead de comunicação entre GPUs;
• Frameworks mais simples de configurar e monitorar.

Quando múltiplas GPUs fazem sentido

• O modelo não cabe em uma única GPU (ex.: Llama 3.1 405B exige múltiplas GPUs);
• Escalabilidade horizontal de throughput — múltiplas réplicas do mesmo modelo;
• Redundância — falha de uma GPU não elimina o serviço completamente.

10. Frameworks de inferência

O framework de inferência impacta diretamente o throughput, a latência e a complexidade de operação. As principais opções abertas em agosto de 2026:

Referências: documentação oficial vLLM (docs.vllm.ai), Ollama (ollama.com), llama.cpp (GitHub), TensorRT-LLM (NVIDIA), Text Generation Inference (Hugging Face), agosto de 2026.

11. GPUs disponíveis para inferência corporativa

Fonte: especificações oficiais NVIDIA (nvidia.com/en-us/data-center/), agosto de 2026. TDP pode variar conforme configuração do servidor.

12. Cenários práticos

13. Escalabilidade e filas

Um serviço de inferência sob carga variável precisa de uma estratégia para lidar com picos sem degradar a qualidade da resposta.

Filas de requisições

Quando o número de requisições simultâneas excede a capacidade de processamento paralelo da GPU, as requisições extras são enfileiradas. Frameworks como vLLM gerenciam isso internamente com continuous batching. O dimensionamento da fila deve considerar o tempo máximo de espera aceitável pelo usuário.

Scaling horizontal

A forma mais direta de escalar inferência é adicionar réplicas do mesmo modelo em GPUs diferentes. Cada réplica atende um conjunto de usuários. Um load balancer distribui as requisições. Essa abordagem exige mais hardware mas mantém a latência previsível.

Scaling vertical

Substituir uma GPU menor por uma maior (ex.: L4 → A100) aumenta tanto o número máximo de usuários simultâneos (mais VRAM para KV cache) quanto o throughput por usuário (maior largura de banda). Tem limite físico — uma GPU tem tamanho máximo de VRAM.

14. Monitoramento em produção

Um serviço de inferência precisa de observabilidade contínua. Os indicadores essenciais:

• Utilização da GPU (%) — deve ser alta (>80%) sem saturar; utilização próxima a 100% constante indica underprovisioning.
• VRAM utilizada (GB) — monitorar para evitar OOM (Out of Memory) que derruba o processo.
• Throughput (tokens/s) — degradação indica problema de software, temperatura ou contenção.
• TTFT (ms) — aumento indica fila crescendo ou problema de latência na rede.
• Comprimento da fila — fila crescente é sinal antecipado de necessidade de escala.
• Temperatura da GPU (°C) — throttling térmico reduz throughput silenciosamente.
• Erros de CUDA / OOM — indicam dimensionamento insuficiente de VRAM.

Para monitorar métricas de GPU NVIDIA, o ponto de partida é nvidia-smi e a biblioteca DCGM (Data Center GPU Manager), que expõe métricas para Prometheus / Grafana.

15. Checklist de dimensionamento

• Modelo definido: nome, versão e número de parâmetros confirmados
• Precisão escolhida: FP16, INT8 ou quantização Q4 — e impacto na qualidade validado
• VRAM dos pesos calculada: parâmetros × bytes por precisão
• Contexto máximo definido: quantos tokens por conversa
• KV cache estimado: usuários simultâneos × contexto × arquitetura do modelo
• Overhead do framework considerado: +1–3 GB
• VRAM total calculada: pesos + KV cache + overhead com margem de 15%
• GPU selecionada com VRAM suficiente
• CPU: mínimo 16 núcleos para serviços de produção
• RAM: ao menos 2× VRAM total da GPU
• Storage: NVMe PCIe 4.0 para tempo de carregamento aceitável
• Framework definido: vLLM para produção, Ollama para desenvolvimento
• Pico de carga considerado (P95 de usuários simultâneos)
• Estratégia de fila ou scaling definida para picos
• Monitoramento configurado: VRAM, temperatura, throughput, fila, TTFT
• Testes de carga realizados com modelo e dados reais antes de produção

Conteúdos relacionados

Perguntas frequentes

{
“@context”: “https://schema.org”,
“@graph”: [
{
“@type”: “Article”,
“headline”: “Como dimensionar GPU para inferência de modelos de IA”,
“description”: “Como calcular VRAM, contexto, KV cache e usuários simultâneos para dimensionar GPU de inferência. Tabelas por modelo, cenários práticos e checklist.”,
“url”: “https://adentro.com.br/gpu-para-inferencia/”,
“datePublished”: “2026-08-05”,
“dateModified”: “2026-08-05”,
“publisher”: {
“@type”: “Organization”,
“name”: “Adentro”,
“url”: “https://adentro.com.br”
},
“inLanguage”: “pt-BR”
},
{
“@type”: “BreadcrumbList”,
“itemListElement”: [
{“@type”:”ListItem”,”position”:1,”name”:”Adentro”,”item”:”https://adentro.com.br”},
{“@type”:”ListItem”,”position”:2,”name”:”Blog”,”item”:”https://adentro.com.br/blog/”},
{“@type”:”ListItem”,”position”:3,”name”:”Infraestrutura para IA”,”item”:”https://adentro.com.br/infraestrutura-para-inteligencia-artificial/”},
{“@type”:”ListItem”,”position”:4,”name”:”GPU para inferência”,”item”:”https://adentro.com.br/gpu-para-inferencia/”}
]
},
{
“@type”: “FAQPage”,
“mainEntity”: [
{
“@type”: “Question”,
“name”: “Qual GPU mínima para rodar Llama 3 8B em produção?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Em FP16, o modelo ocupa cerca de 16 GB de VRAM — uma L4 (24 GB) serve para até ~10 usuários simultâneos com contexto de 2k tokens. Em INT8, a T4 (16 GB) pode ser suficiente para uso interno leve.”
}
},
{
“@type”: “Question”,
“name”: “Posso rodar um modelo de 70B em uma única GPU?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Em FP16 é impossível com GPUs atuais. Em INT8 (~70 GB), são necessários dois A100 80GB. Em Q4_K_M (~38–42 GB), uma L40S (48 GB) pode servir com pouco espaço para KV cache.”
}
},
{
“@type”: “Question”,
“name”: “GPU dedicada ou cloud sob demanda para inferência?”,
“acceptedAnswer”: {
“@type”: “Answer”,
“text”: “Cloud sob demanda é mais flexível para picos e desenvolvimento. GPU dedicada tem custo previsível e pode ser mais econômica com utilização constante acima de 40–50%, além de oferecer isolamento de dados e conformidade mais simples.”
}
}
]
}
]
}

document.querySelectorAll(‘.faq-q’).forEach(q => {
q.addEventListener(‘click’, () => {
q.parentElement.classList.toggle(‘open’);
});
});