Calculadora de hardware para LLM

Cache KV

Até 262144 para qwen3-*. A qualidade cai além do contexto nativo.

qwen3-32b · Q4_K_M · KV=Q8

pesos ~17.6 GB · KV 131 KB/token · necessário ~36.8 GB para 131,072

Gargalo: KV 47% / pesos 48% / overhead 5%

  • 2x RTX 3090max 131,07243-64 tok/s
  • RTX 4090 48GBmax 131,07229-43 tok/s

Unidades decimais: 1 GB=109 bytes1\,\text{GB} = 10^{9}\,\text{bytes}, 1 KB=103 bytes1\,\text{KB} = 10^{3}\,\text{bytes}. Não GiB/KiB.

Offload para CPU não é considerado um modo de ajuste; mmap afeta apenas carregamento, não a contagem de VRAM.

Estima apenas decodificação; prefill de contextos grandes não é modelado. Em MoEs gigantes, prefill é o verdadeiro gargalo.

decode-only estimate; anchors: llama.cpp single stream, 2026-09

Sobre as estimativas

  • Decodificação de fluxo único (batch=1\text{batch} = 1) calibrada com medições do llama.cpp de setembro de 2026.
  • Unidades decimais: 1 GB=109 bytes1\,\text{GB} = 10^{9}\,\text{bytes}. Máquinas unificadas reservam 4 GB para o sistema.
  • A decodificação MoE lê apenas especialistas ativos, com fator 0,35× por limitação de latência.
  • KV Q8 reduz o cache à metade com perda mínima de qualidade.

Sobre esta ferramenta

Esta calculadora estima se um modelo de linguagem grande cabe em determinada GPU ou Mac e com que velocidade ele geraria texto. Ela foi pensada para quem roda modelos localmente com llama.cpp e ferramentas semelhantes. A quantização armazena os pesos do modelo com menor precisão, o que reduz o uso de memória com uma pequena perda de qualidade; a calculadora conta o Q4_K_M como 0,55 byte por parâmetro. O cache KV guarda dados de atenção para cada token do contexto.

Dois números do hardware decidem o resultado. A capacidade de memória determina se os pesos e o contexto desejado chegam a carregar, e a largura de banda da memória determina a rapidez com que os tokens aparecem depois disso. Uma placa com muita memória e pouca largura de banda, como uma GPU de data center mais antiga, pode comportar um modelo grande e ainda assim gerar devagar.

Como funciona

Em Encontrar hardware, escolha um modelo, uma quantização e a precisão do cache KV e, em seguida, informe o tamanho do contexto e a velocidade mínima aceitável em tokens por segundo; o YaRN é opcional. A ferramenta lista as máquinas aprovadas, com necessidade de memória e faixa de velocidade. Em Verificar meu hardware, escolha uma máquina, as quantizações a comparar e um contexto-alvo para ver quais modelos cabem.

A memória necessária é o tamanho dos pesos mais o cache KV do contexto inteiro mais uma sobrecarga fixa de 2 GB. Os pesos em GB são bilhões de parâmetros vezes bytes por parâmetro: 0,55 para Q4_K_M, 0,65 para Q5_K_M, 0,75 para Q6_K, 1,07 para Q8_0 e 2,0 para BF16. O cache por token é 2×L×Hkv×dhead2 \times L \times H_{kv} \times d_{head} bytes em Q8 e o dobro em FP16, em que L é o número de camadas. A velocidade de decodificação é estimada como 50% a 75% da largura de banda efetiva dividida pelo tamanho dos pesos ativos, com fatores de eficiência menores para hardware sem CUDA, como GPUs AMD e chips Apple.

Exemplo

Para o qwen3-32b em Q4_K_M com cache KV Q8, os pesos ocupam 32×0,55=17,632 \times 0{,}55 = 17{,}6 GB e o cache ocupa 131,072 KB por token. Em uma RTX 4090 de 24 GB, depois de 2 GB de sobrecarga e 0,5 GB de reserva, cabem cerca de 29.754 tokens de contexto, então uma meta de 32.768 tokens não é atingida. A velocidade estimada de decodificação fica entre 28,6 e 43,0 tokens por segundo.

Agora considere o llama3.3-70b em Q4_K_M em um M4 Max com 128 GB de memória unificada. Os pesos precisam de 70×0,55=38,570 \times 0{,}55 = 38{,}5 GB e o cache Q8 de 163,84 KB por token, então um contexto de 32.768 tokens exige cerca de 45,9 GB no total, e até o contexto nativo completo de 131.072 tokens cabe depois da reserva de 4 GB. O gargalo é a velocidade: a estimativa é de apenas 5,0 a 7,4 tokens por segundo, porque cada token lê todos os 38,5 GB de pesos com 546 GB/s de largura de banda.

Premissas e limites

As estimativas valem apenas para decodificação em fluxo único, calibradas com medições do llama.cpp; o tempo de processamento do prompt não é modelado. A memória usa gigabytes decimais, um overhead fixo de 2 GB e uma reserva de 0,5 GB em GPUs dedicadas ou de 4 GB em máquinas com memória unificada. Descarregamento para a CPU e encaixes parciais não são considerados. As listas de modelos e de hardware são catálogos fixos, e as velocidades reais variam conforme drivers e configurações.

Perguntas frequentes

Quanta VRAM é preciso para rodar um LLM localmente?

Aproximadamente o tamanho dos pesos quantizados mais o cache KV para o seu contexto, mais alguma sobrecarga. Uma quantização de 4 bits precisa de pouco mais de meio gigabyte por bilhão de parâmetros só para os pesos, então um modelo de 32B precisa de cerca de 18 GB antes do contexto. Contextos longos somam rápido, por isso confira o valor do cache para o tamanho desejado antes de comprar hardware.

O que significa Q4_K_M?

Q4_K_M é um tipo de quantização GGUF do llama.cpp que armazena a maioria dos pesos com cerca de 4 bits pelo método k-quant, mantendo alguns tensores com precisão maior. É um padrão comum porque equilibra tamanho de arquivo e qualidade da saída. Q5_K_M e Q6_K preservam mais detalhes com arquivos maiores, e o Q8_0 fica próximo do modelo original em qualidade.

Por que a velocidade de geração é limitada pela largura de banda da memória?

Ao gerar um token por vez, o hardware precisa ler da memória todos os pesos ativos a cada token. Por isso, tokens por segundo equivalem aproximadamente à largura de banda da memória dividida pelo tamanho dos pesos ativos. É por isso que uma quantização menor roda mais rápido na mesma máquina e que a largura de banda importa mais que o poder de cálculo bruto em um chat local.

Por que modelos mixture-of-experts precisam de muita memória, mas rodam rápido?

Um modelo mixture-of-experts precisa manter todos os especialistas na memória, mas cada token usa só alguns deles. A memória acompanha o total de parâmetros, enquanto a velocidade de decodificação acompanha o número menor de parâmetros ativos. Por exemplo, o qwen3-30b-a3b precisa de memória para 30 bilhões de parâmetros, mas lê apenas cerca de 3 bilhões por token.

Por que os tokens por segundo que eu meço são diferentes da estimativa?

A estimativa é uma faixa calibrada para decodificação de fluxo único no llama.cpp, então outros programas, drivers, tamanhos de lote e limites térmicos deslocam os números reais para cima ou para baixo. O processamento do prompt não é modelado, de modo que prompts longos acrescentam espera antes do primeiro token. Se parte do modelo for transferida para a RAM do sistema, a velocidade cai muito abaixo da estimativa, porque a calculadora considera apenas o caso em que o modelo cabe inteiro na memória.

Link com os seus valores

Adicione estes parâmetros ao endereço desta página para abri-la com os valores já preenchidos, por exemplo para compartilhar um cálculo ou criar um link a partir de um assistente de IA. O resultado é calculado no navegador: o HTML da página mostra um exemplo com os valores padrão, e a ferramenta define o atributo data-url-params quando os valores do link são aplicados.

ParâmetroValorSe omitido
modeCálculoum destes: need, hardwarepadrão: need
modelModeloum destes: qwen3-8b, qwen3-14b, qwen3-30b-a3b, qwen3-32b, llama3.1-8b, llama3.3-70b, qwen3-235b-a22b, qwen3-480b-a22b, qwen3-4b, gpt-oss-20b, gpt-oss-120b, deepseek-r1-distill-qwen-32b, qwen3-coder-30b-a3b, phi-4, qwen2.5-coder-32b; usado com mode = needpadrão: qwen3-32b
quantQuantizaçãoum destes: Q4_K_M, Q5_K_M, Q6_K, Q8_0, BF16; usado com mode = needpadrão: Q4_K_M
context_tokensContexto (tokens)número inteiro; permitido ≥ 0; usado com mode = needpadrão: 131072
min_tokens_per_sMín. tok/snúmero; permitido ≥ 0; usado com mode = needpadrão: 20
hardwareHardwareum destes: rtx_3090, rtx_4090, rtx_4090_48gb, rtx_5090, tesla_p40, tesla_p100_16gb, tesla_v100_32gb, mi50_32gb, 2x_rtx_3090, m4_pro, m5_pro, m5_max, m4_max, m3_ultra, dgx_spark_gb10, dgx_station_gb300; usado com mode = hardwarepadrão: rtx_4090
quantsQuantizaçõesvalores separados por vírgulas: 2,4,4,6; usado com mode = hardwarepadrão: Q4_K_M,Q8_0
target_context_tokensContexto-alvonúmero inteiro; permitido ≥ 0; usado com mode = hardwarepadrão: 131072
kv_cacheCache KVum destes: q8, fp16padrão: q8
yarn_tokensYaRN (opcional)número inteiro; permitido 1–262144opcional

Exemplos

  • ?model=llama3.3-70b&quant=Q5_K_M&context_tokens=32768&kv_cache=fp16&min_tokens_per_s=15
  • ?hardware=m4_max&quants=Q4_K_M,Q6_K&target_context_tokens=65536

Escreva decimais com ponto. Codifique um espaço como %20, + como %2B, # como %23 e & como %26.

Elementos do resultado: [data-result-block="llm-hardware"]