Toda a pergunta "esse modelo cabe na minha máquina?" se reduz a uma multiplicação que cabe na cabeça. Esta lição instala a fórmula de VRAM de Ahmad Osman, a escada de quantização que sai dela, e o reflexo de calcular antes de baixar 81 GB. No fim, você olha para "284B" e sabe — em segundos — que só ~2 bits cabem nos seus 128 GB.
Não existe mistério no tamanho de um modelo. Cada parâmetro é um número, e quantos bytes ele ocupa depende apenas de quantos bits você usa para guardá-lo. Some todos os parâmetros e tem a memória dos pesos. Ahmad reduz isso a uma linha:
VRAM (em GB) ≈ Parâmetros (bilhões) × (bits efetivos ÷ 8).— Ahmad Osman, "GPU Memory Math (2026)"
O ÷ 8 converte bits em bytes; "bilhões de parâmetros" casa com "gigabytes" sem fatores extras. FP16 usa 16 bits → 16/8 = 2 bytes por parâmetro, então um modelo de N bilhões pesa 2N GB. É só isso. O diagrama trata a fórmula como uma esteira: parâmetros entram, a precisão multiplica, GB saem.
A precisão é o único botão que muda o resultado. O número de parâmetros é fixo; baixar de FP16 para ~2 bits é o que tira 568 GB e devolve algo que cabe.
Quantizar é guardar cada parâmetro com menos bits. Cada degrau abaixo de FP16 corta memória — e morde um pouco de qualidade. Esta é a escada em GB por bilhão de parâmetros; multiplique pelo tamanho do seu modelo para ter a estimativa. Repare que os k-quants (Q6_K…Q2_K) não são números redondos: incluem o overhead real do formato.
| Precisão | Bits efetivos | GB por 1B params | Custo |
|---|---|---|---|
| FP16 | 16 | 2,00 | referência (qualidade máxima) |
| FP8 / INT8 | 8 | 1,00 | perda quase imperceptível |
| Q6_K | ~6,6 | ≈ 0,82 | diferença mínima vs FP16 |
| Q5_K | ~5,5 | ≈ 0,69 | muito boa |
| Q4_K | ~4,5 | ≈ 0,56 | o "ponto-doce" usual |
| Q3_K | ~3,4 | ≈ 0,43 | degradação perceptível |
| Q2_K | ~2,6 | ≈ 0,33 | último recurso p/ caber |
Agora a escada aplicada ao caso real desta máquina: o DeepSeek-V4-Flash de 284B. O gráfico abaixo é à escala dentro da janela de 0–128 GB; tudo que estoura é cortado na borda com uma seta e o valor verdadeiro. A linha vertical marca os 128 GB de memória unificada.
As três barras vermelhas/laranja saem da janela: FP16, FP8 e até Q4 não cabem em 128 GB para um modelo de 284B. Só ~2 bits ficam à esquerda da linha — e o GGUF q2 real (81 GB) é ainda mais magro que a estimativa da fórmula (94 GB).
GGUF não é mágica… "cabe em 6 GB" não é verdade universal. É uma verdade específica do runtime.— Ahmad Osman, "LLMs 101 (2026)"
Junte a fórmula com a sua RAM e nasce um mapa de decisão. As linhas são tamanhos de modelo; as colunas, precisões. Cada célula responde "esses pesos cabem nos 128 GB?" (deixando ~20% de folga, ou seja, alvo prático ≈ 102 GB). Verde cabe, vermelho não.
Leia na diagonal: quanto maior o modelo, mais à direita (mais agressiva a quantização) você precisa ir só para entrar na janela. Para 284B, a única coluna verde é Q2 — e mesmo assim por causa do GGUF real de 81 GB, abaixo da estimativa de 94.
A grade não diz "rode sempre em Q2". Diz o que é fisicamente possível. A célula verde mais à esquerda de cada linha é a sua melhor opção de qualidade que ainda cabe — e a Lição 03 (banda de memória) vai explicar por que, mesmo cabendo, o tamanho ainda decide a velocidade.
"Cabe" não é o mesmo que "roda bem". O sistema operacional, os apps, o KV cache do contexto e a fragmentação de memória precisam de espaço. Encher a RAM até a borda é o caminho mais curto para um crash por out-of-memory no meio de uma geração.
Deixe 10 a 20 por cento de folga. Rodar a 99% da VRAM é implorar por out-of-memory e falhas de fragmentação.— Ahmad Osman, "GPU Memory Math (2026)"
Os 81 GB do cérebro pousam à esquerda da linha de 80%, deixando ~21 GB para o KV cache do contexto e o sistema. Encostar nos 128 (a região sombreada) é onde a fragmentação derruba a sessão.
O reflexo errado é "maior é sempre melhor". Não é. Esmagar um modelo grande em pouquíssimos bits pode destruir mais qualidade do que ganhar com a contagem de parâmetros. Um modelo menor em precisão decente frequentemente vence um maior espremido demais.
Um modelo menor em precisão mais alta pode bater um modelo maior esmagado em poucos bits — um 7B em Q6 pode vencer um 13B em Q2 em raciocínio.— Ahmad Osman, "GPU Memory Math (2026)"
Os dois ocupam ~5 GB — empate de memória. Mas o 13B perdeu tanta precisão por parâmetro que o 7B bem preservado raciocina melhor. Tamanho compra capacidade só se os bits sobreviverem.
Quantização vem com pegadinha de procedência. Formatos como GGUF e safetensors guardam apenas tensores — dados. O formato antigo .bin baseado em pickle do PyTorch pode embutir código que executa ao carregar. Baixar pesos é baixar dados; não deveria rodar nada.
Evite arquivos .bin aleatórios de fontes não confiáveis (pickle = execução de código). Prefira GGUF/safetensors.— Ahmad Osman, "GPU Memory Math (2026)"
1) Prefira GGUF (runtimes tipo llama.cpp/MLX) ou safetensors — ambos são só tensores, sem execução. 2) Trate .bin/.pt/.pth de fonte desconhecida como suspeitos. 3) Confira o publicador e o hash quando houver. A fórmula te diz se cabe; a procedência te diz se é seguro carregar.