Curso / Lição 02
Lição 02 · Capacidade

Matemática de memória

Uma única conta decide o que você consegue rodar localmente: o que cabe na RAM. No fim desta lição você vai prever, de cabeça, se um modelo entra nos seus 128 GB — e vai entender por que o DeepSeek-V4-Flash (284 B) só cabe em 2 bits, e por que mesmo assim continua inteligente.

Leia primeiro (fonte primária)
Ahmad Osman — "GPU Memory Math for LLMs (2026 Edition)"

Esta lição destila esse artigo + medições reais no M5 Max. Os números todos têm fonte (rodapé). Por que importa pra missão: é o filtro que diz, antes do download, se o cérebro local do Alembic roda neste Mac.

Objetivos desta lição
  • Prever de cabeça se um modelo cabe nos 128 GB com a fórmula params × bits ÷ 8.
  • Ler a escada de quantização (FP16 → Q2) e o que cada degrau custa em qualidade.
  • Aplicar a folga de 10–20% (pesos + KV + SO) sem estourar a RAM.
  • Explicar por que o DeepSeek-V4-Flash sobrevive a 2 bits (quant assimétrica).
0 B
params · DeepSeek-V4-Flash
0 GB
o GGUF q2 real (cabe!)
0 GB
RAM do seu M5 Max
0 bits
única quant que cabe

01 · A fórmula que decide tudo

Antes de qualquer download, antes de escolher engine, antes de pensar em velocidade, existe uma pergunta que ou passa ou reprova o modelo: os pesos cabem na memória? Se não cabem, nada mais importa — o modelo nem carrega. E a conta para responder isso é deliberadamente simples:

VRAM (em GB) ≈ Parâmetros (bilhões) × (bits efetivos ÷ 8). That's it.— Ahmad Osman, "GPU Memory Math for LLMs (2026)"

Anatomia: o que cada termo significa

A fórmula tem três peças, e cada uma é um conceito que vale entender de verdade — não decorar:

A FÓRMULA, PEÇA POR PEÇA · 284B × 2 bits ÷ 8 = 71 GB
284 B parâmetros (pesos) × 2 bits precisão por peso ÷ 8 ≈ 71 GB pesos na RAM cabe ✓ quantos números o modelo aprendeu quantos bits guardam cada número ÷8 = bits viram bytes (1 byte = 8 bits)

Parâmetros são os números que o modelo aprendeu no treino — os "pesos". Um modelo "de 284 B" tem 284 bilhões deles. Bits por peso é quanta precisão você guarda de cada número: 16 bits é o original de treino; 2 bits é uma versão fortemente comprimida. O ÷ 8 só converte bits em bytes (8 bits = 1 byte), porque memória se mede em bytes. Multiplique os três e você tem os gigabytes que os pesos ocupam — antes de KV cache e sistema (que entram na seção 05 e na Lição 06).

Preveja antes de continuar
O DeepSeek-V4-Flash tem 284 B de parâmetros. Na precisão original de treino (FP16 = 16 bits/peso), quanta RAM os pesos sozinhos exigiriam? Chute uma ordem de grandeza antes de revelar.
≈ 568 GB. A conta: 284 × 16 ÷ 8 = 568 GB — mais de os 128 GB do seu Mac, e mais que o Mac Studio topo de linha (512 GB). Se você chutou "uns 100 GB", subestimou o custo do FP16: cada peso em 16 bits custa 2 bytes, e 284 bilhões deles somam meio terabyte. É exatamente por isso que rodar local exige quantizar — assunto da próxima seção.

Cabe ou não cabe? O mesmo modelo, duas precisões

O veredito de capacidade é binário: ou os pesos entram nos 128 GB, ou o modelo nem carrega. Veja o mesmo DeepSeek-V4-Flash decidido pela fórmula em duas precisões — FP16 estoura, Q2 entra:

DEEPSEEK-V4-FLASH · FP16 (não cabe) vs Q2 (cabe) — o veredito é binário
FP16 · 16 bits/peso 284 B × 16 ÷ 8 = 568 GB de pesos ✗ NÃO CABE 568 GB ≫ 128 GB (4,4× o teto) Q2_K · ~2 bits/peso 284 B × 2 ÷ 8 ≈ 71 GB (GGUF real 81 GB) ✓ CABE 81 GB < 128 GB · sobra p/ KV+SO Mesmos 284 bilhões de pesos — só muda quantos bits guardam cada um. 8× menos bits = 8× menos RAM.

Agora calcule você mesmo

Arraste os dois sliders. A barra cresce em escala real e troca de cor — verde = cabe, vermelho = não cabe nos 128 GB do M5 Max:

0 128 GB (limite do M5 Max) 71 GB

Escala: 0–170 GB · a linha vermelha é o teto do seu Mac. Repare: 284 B em 16-bit = 568 GB (some da tela); só em ~2 bits (≈71 GB) entra.

Conta de guardanapo ≠ arquivo real
71 GB é a estimativa da fórmula. O GGUF real do DeepSeek-V4-Flash q2 do antirez pesa 81 GB — a diferença é overhead (metadados, embeddings e camadas que ele não esmaga até 2 bits; veja a seção 05). A fórmula te dá a ordem de grandeza em segundos; o arquivo confirma os detalhes.

02 · O que é, de fato, "quantização"

A fórmula mostrou que bits por peso é a alavanca da memória. Quantizar é puxar essa alavanca: guardar cada peso em menos bits. O modelo treina em 16 bits (FP16/BF16) por peso; quantizar reescreve esses mesmos pesos numa grade mais grossa de valores — menos casas, menos memória, alguma perda de fidelidade.

O MESMO PESO, EM 3 PRECISÕES · cada quadradinho = 1 bit guardado
FP1616 bits 2.0 GB / 1B · fidelidade total Q4_K~4 bits ~0.56 GB / 1B · sweet spot Q2_K~2 bits ~0.33 GB / 1B · cabe 284B

De 16 para 2 quadrados por peso = ⅛ da memória. Mas com menos bits sobram menos valores possíveis: a grade fica grossa e detalhes finos (justo os que importam para raciocínio e código) começam a sumir.

A escada completa — e o que cada degrau custa

Não existe só "16 ou 2". Há uma escada de formatos. Esta é a referência prática para o seu Mac, em GB por bilhão de parâmetros:

FormatoBitsGB / 1BQuando usar
FP16 / BF16162.0Treino e referência; raramente para rodar local (caro demais)
FP881.0Quase sem perda; ótimo se a memória permite
Q6_K~60.82Praticamente indistinguível do original
Q4_K~40.56Sweet spot consumer — melhor equilíbrio qualidade/tamanho
Q2_K~20.33Só para caber um modelo grande; degrada math/código/tools

Mexa o slider abaixo: o degrau correspondente acende. Veja como a barra encolhe a cada formato — é a memória que você economiza, e (seção 05) a qualidade que arrisca:

FP16 (16b)2.0 FP8 (8b)1.0 Q6_K (~6b)0.82 Q4_K (~4b)0.56 Q2_K (~2b)0.33 ← cabe 284B Q4 = sweet spot consumer · Q2/Q3 = "só quando precisa caber um modelo maior" (math/code/tools degradam — Lição 04)

A escada como escada: cada degrau troca memória por fidelidade

Pense na quantização como uma escada que você desce: cada degrau abaixo corta a memória, mas também corta um pouco da fidelidade. Você desce só até onde precisa caber — nem um degrau a mais, porque cada degrau abaixo do necessário é qualidade jogada fora de graça:

A ESCADA DA QUANTIZAÇÃO · descer = menos GB, menos fidelidade (DS4 para em Q2)
FP16 · 568 GB Q8 · 284 GB Q6 · ~233 GB Q4 · 159 GB ✗ Q2 · 81 GB ✓ cabe DS4 para aqui + fidelidade + perda ← menos memória a cada degrau · desça só até caber (descer demais = qualidade perdida de graça)

03 · O que cabe nos seus 128 GB

Com a fórmula e a escada na mão, dá para responder a pergunta de capacidade para qualquer modelo. Duas leituras complementares: primeiro um caso concreto (o DeepSeek-V4-Flash de 284 B em cada precisão), depois uma grade geral para você explorar.

O caso do 284 B, em escala real

As barras abaixo estão na mesma escala do teto de 128 GB. Repare: só a Q2 cruza para baixo da linha.

DEEPSEEK-V4-FLASH (284B) · MEMÓRIA DOS PESOS POR PRECISÃO vs TETO 128 GB
teto 128 GB FP16 568 GB ↗ fora da tela Q4_K 159 GB · não cabe Q2_K 81 GB real · cabe ✓ escala: 1 GB ≈ 1.27 px · 0 ────────────── 128 (linha) ─────── ~640 GB

É por isso que o DS4 quantiza em 2 bits: não é escolha estética, é a única precisão em que um modelo desse porte entra em 128 GB. Em Q4 já seriam 159 GB — você precisaria de um Mac Studio de 256 GB.

A grade geral — explore

Mexa o slider de tamanho: a linha do modelo acende e cada célula mostra ✓ (cabe) / ✗ (não cabe) em 128 GB, com os GB de pesos calculados pela fórmula.

A 284 B (DeepSeek-V4-Flash) só a coluna Q2 fica verde — exatamente por isso o DS4 quantiza em 2 bits. Já um 70 B cabe folgado até em Q4.

04 · Faça a conta na mão (passo a passo → agora você)

Você já viu a fórmula girar nos sliders. Agora faça-a na mão, devagar, com o caso de referência — depois um exercício é seu. Recuperar o procedimento (não só ver o número pronto) é o que fixa de verdade.

Exemplo resolvido · cabe o DeepSeek-V4-Flash (284 B) em Q2 nos 128 GB?
1
Pegue os parâmetros. O DS4 tem 284 B de pesos no total. (Para memória, conta o total — diferente de velocidade, onde só os ~13 B ativos importam; ver Lição 03.)
2
Escolha os bits/peso. Q2_K ≈ 2 bits por peso. É a alavanca da memória da seção 02.
3
Aplique a fórmula. params × bits ÷ 8 = 284 × 2 ÷ 8 = 71 GB de pesos (conta de guardanapo).
4
Ajuste para o arquivo real. O GGUF q2 do antirez pesa 81 GB — os ~10 GB a mais são as camadas críticas mantidas em Q8 (a quant assimétrica da seção 07). Use o número real quando tiver.
5
Veredito. 81 GB < 128 GB → cabe ✓, e ainda sobram ~47 GB para KV cache + SO (a folga da próxima seção).
Agora você: um Llama-70 B em Q4_K (~4 bits). Quanto de pesos? Cabe nos 128 GB? Faça antes de revelar.
70 × 4 ÷ 8 = 35 GB de pesos → cabe com folga enorme (sobram ~93 GB para KV + SO + um segundo modelo, se quiser). Dica: o procedimento é sempre o mesmo — só trocam os três números. Repare como o desafio do curso é o oposto: caber um gigante (284 B), não um 70 B.

05 · A folga: nunca encha a RAM até 100%

Os pesos são só uma parte do que ocupa a memória durante a inferência. Encher a RAM até a borda com os pesos e achar que "cabe" é um erro clássico — na hora de rodar, mais coisas disputam o mesmo espaço:

Leave 10 to 20 percent headroom. Running at 99 percent VRAM is begging for out-of-memory and fragmentation failures.— Ahmad Osman, "LLMs 101 (2026)"
O que mais ocupa RAM além dos pesos:
KV cache — a memória de trabalho da conversa; cresce com o tamanho do contexto (~0,5 MiB por token em FP16; detalhes na Lição 06).
Ativações — buffers temporários de cada passo.
SO + apps — o macOS e seus programas precisam de vários GB.
Por que a folga importa:
OOM — estourar a memória mata o processo na hora.
Fragmentação — alocar perto do limite falha mesmo "tendo" espaço.
Contexto longo — o KV cresce durante a geração; o que cabia no início pode estourar no fim.
PILHA DE MEMÓRIA EM USO · exemplo com pesos q2 (81 GB) num contexto médio
teto seguro 80% (102 GB) pesos 81 GB KV ~15 SO+app ~10 · livre ~22 soma ≈ 106 GB — perto do teto seguro: por isso em 128 GB você roda o q2 com contexto moderado, não com 1M de tokens (Lição 06).

Agora sinta a regra: arraste o uso total e veja quando você cruza o teto seguro de 80% (~102 GB):

teto seguro 80% (102 GB) 107 GB

06 · Decisão: "esse modelo roda no meu Mac?" (fluxograma)

Junte a fórmula, a escada e a folga numa única decisão. Diante de qualquer modelo novo, siga este fluxograma de cabeça: ele leva da pergunta de capacidade até o veredito "baixa" ou "pula". Siga as setas — cada losango é uma pergunta que escolhe o caminho.

FLUXOGRAMA · "ESSE MODELO CABE?" — da fórmula ao veredito (o caminho do DS4 destacado)
novo modelo de N B params × bits ÷ 8 = pesos pesos + KV + SO ≤ ~102 GB (80%)? SIM ✓ BAIXA roda local NÃO já está no degrau mais baixo (~2 bits)? NÃO → desça um degrau e recalcule SIM ✗ PULA (ou Mac maior) 2 bits e ainda > 102 GB → não entra caminho do DS4 (284 B): Q4=159 GB (não) → desce → Q2=81 GB (sim) → ✓ baixa
Por que o losango da folga (não dos pesos puros): o teste não é "pesos ≤ 128 GB", é "pesos + KV + SO ≤ ~102 GB". Quem compara só os pesos com os 128 GB cai em OOM quando o KV cresce no contexto longo (seção 05).
O loop "desça um degrau": é exatamente o que o antirez fez com o DS4 — Q4 não cabia (159 GB), então desceu para Q2 (81 GB). O fluxograma só para quando cabe ou quando já está no degrau mais baixo e ainda estoura.

07 · Menor+preciso vence maior+esmagado

A tentação é sempre "baixar o maior modelo que couber". Mas memória não é a única variável — fidelidade por peso também conta. Um modelo menor em alta precisão frequentemente ganha de um maior comprimido demais:

A smaller model at higher precision can beat a larger model crushed into too few bits.— Ahmad Osman, "LLMs 101 (2026)"

Clique para comparar dois modelos que ocupam memória parecida:

7B em Q6: menos params, mas alta precisão. Em raciocínio/código costuma vencer o 13B-Q2 — e ainda usa menos memória. ★ A precisão preserva justamente o que o Q2 quebra primeiro (math, tools, JSON estruturado).
13B em Q2: mais params no papel, mas esmagado em 2 bits ingênuos. Degrada onde mais importa (raciocínio, tool-use) — exceto na receita assimétrica do DS4, abaixo, que é o truque que salva o DeepSeek a 2 bits.

Então como o DeepSeek (284B) sobrevive a 2 bits?

Aqui está a peça que fecha a lição. Se 2-bit ingênuo destrói a qualidade, como o DS4 entrega um modelo de 284 B em 81 GB que ainda chama ferramentas de forma confiável? A resposta é quantização assimétrica: ele não esmaga tudo igual. A maior parte do volume (os "experts" do MoE, que raramente são acionados juntos) vai para 2 bits; as poucas camadas críticas (atenção, projeções compartilhadas, roteamento) ficam em 8 bits.

RECEITA ASSIMÉTRICA DO DS4 · por volume de pesos (não por importância)
~maioria dos pesos · experts MoE → IQ2_XXS / Q2_K (2 bits) crítico → Q8 Volume grande, esmagado a 2 bits ↑ ↑ atenção/roteamento intactos Resultado: o tamanho cai 8× onde dá, mas o "cérebro" que decide e chama tools fica preciso.
It's not a joke — it calls tools reliably even at 2-bit.— antirez, DS4 MODEL_CARD (sobre a quant assimétrica do DeepSeek-V4-Flash)

É por isso que o GGUF real dá 81 GB e não os 71 da conta limpa: aquele "a mais" são as camadas mantidas em Q8 de propósito. A fórmula te diz o piso; a engenharia da quantização decide se o modelo continua útil — assunto inteiro da Lição 04.

Segurança ao baixar pesos
"Do not let a stranger's model file become a stranger's code execution." Evite arquivos .bin/pickle de fontes não-confiáveis (pickle executa código ao carregar); prefira GGUF ou safetensors, que são só dados. — Ahmad Osman.

08 · Q2 vs Q4 vs FP16: o trade-off lado a lado

Toda a lição gira em torno de um trade-off: menos bits = menos RAM, mas menos qualidade. Veja-o explícito, na mesma tabela, para os mesmos 284 B do DS4 — memória, veredito de capacidade e o que cada precisão custa em fidelidade. A tabela diz os números; o gráfico abaixo torna o trade-off visível.

PrecisãoBits/pesoPesos (284 B)Cabe em 128 GB?O que você ganha / perde
FP1616568 GB✗ não (4,4× o teto)Fidelidade total · impossível local
Q88284 GB✗ não (2,2× o teto)Quase sem perda · ainda grande demais
Q4_K~4159 GB✗ não (1,2× o teto)Sweet spot — mas só num Mac de 256 GB
Q2_K~271 GB (81 real)✓ sim · única que entraCabe! · math/código/tools degradam — salvo a quant assimétrica do DS4

O gráfico de barras empilha as duas dimensões: a altura é a memória; a cor da etiqueta é o veredito. Só a barra da Q2 cruza para baixo da linha dos 128 GB:

284 B EM 4 PRECISÕES · memória dos pesos vs teto de 128 GB (escala comprimida no topo)
teto 128 GB 568 GB ✗ FP16 16 bits 284 GB ✗ Q8 · 8 bits 159 GB ✗ Q4 · ~4 bits 81 GB ✓ Q2 · ~2 bits FP16/Q8 saem da escala (⤒) · só Q2 fica abaixo da linha → é a única precisão que entra em 128 GB.
Leia o trade-off ao contrário: a tabela parece dizer "sempre Q2", mas é só porque o modelo é gigante (284 B). Para um modelo que já cabe (ex.: 70 B), você sobe a escada o quanto a RAM deixar — Q6 ou Q8 — porque aí a fidelidade é de graça. Quantizar fundo é o preço de caber um gigante, não um objetivo em si (seção 07 e Lição 04).

O orçamento dos 128 GB — onde cada GB vai (Q2)

Caber os pesos é metade da história. Os 128 GB são um orçamento repartido entre pesos, KV cache, sistema operacional e a folga obrigatória. Veja a divisão típica rodando o DS4 q2 com contexto moderado:

ORÇAMENTO DE 128 GB · como os gigabytes se repartem rodando o DS4 q2
128 GB = orçamento total (cada segmento é uma fatia real) pesos · 81 GB 63% do orçamento KV ~15 SO ~10 folga ~22 17% livre teto seguro 80% (102 GB) Pesos + KV + SO ≈ 106 GB — encostado no teto seguro. Por isso, em 128 GB, o q2 roda com contexto moderado, não com 1M de tokens (o KV cresceria e estouraria — Lição 06). A folga não é desperdício: é o seguro contra OOM. Números: pesos 81 GB (GGUF real medido) · KV/SO/folga = estimativa de contexto moderado. [uncertain] KV exato varia com o tamanho do contexto.

Fixe os conceitos (flashcards)

Clique pra virar. Tente lembrar a resposta antes de virar — recuperação ativa fixa mais que reler.

Fórmula
Como estimar a RAM dos pesos?
clique pra virar ↻
Resposta
VRAM (GB) ≈ params (B) × bits ÷ 8. Ex.: 284 × 2 ÷ 8 = 71 GB (napkin); o GGUF q2 real = 81 GB.
Quantização
Quanto custa Q2_K em GB por 1 B?
clique pra virar ↻
Resposta
~0,33 GB/1B (vs 2,0 em FP16) — ⅛ da memória, mas degrada math/código/tools.
Folga
Qual o teto seguro em 128 GB?
clique pra virar ↻
Resposta
~102 GB (80%). Deixe 10–20% livre p/ KV + SO + ativações; rodar a 99% pede OOM/fragmentação.
DS4
Por que 284 B chama tools bem em 2 bits?
clique pra virar ↻
Resposta
Quant assimétrica: experts MoE em 2 bits, atenção/roteamento mantidos em Q8. Por isso o arquivo dá 81 GB, não 71.

Revisão cumulativa — recupere de memória

Antes de clicar: responda de cabeça. As quatro opções têm o mesmo tamanho de propósito — sem pista pela forma.

1. Um modelo de 70 B em Q4_K (~0.56 GB/1B) cabe nos seus 128 GB?
Correto: c — 70 × 0,56 ≈ 39 GB só de pesos; sobra muito dentro dos 128 GB. a erra a escala: 70 B em Q4 são ~39 GB, não 256 GB (256 GB só faria falta para um Q4 de 284 B, que dá 159). b inventa "streaming de SSD" — os pesos entram inteiros na RAM unificada; disco só conta no carregamento. d confunde "cabe" com "cabe justo": 39 GB deixa ~89 GB livres, o oposto de sem folga. O desafio real é o inverso — caber um GIGANTE (284 B), e aí 2-bit + engine especializado entram.
2. Por que 284 B só "cabe" em 128 GB a aproximadamente 2 bits?
Correto: b — a fórmula manda: 284 × 2 ÷ 8 ≈ 71 GB (real 81), e em 4-bit já seriam 159 GB, fora dos 128. a inverte a verdade: 2 bits deixa o modelo menos preciso, não mais esperto — ele só cabe. c apela para uma "compressão automática do macOS" que não existe para pesos de LLM na GPU. d é factualmente falso: 284 B é enorme — só "cabe" por causa dos 2 bits + da quant assimétrica.
3. Por que o DeepSeek continua chamando ferramentas bem em 2 bits?
Correto: a — quant assimétrica: o volume (experts MoE) é esmagado a 2 bits, mas atenção/roteamento ficam em Q8, então o "cérebro" que decide e chama tools continua preciso. Por isso o arquivo dá 81 GB (e não os 71 da conta limpa) — é o Q8 extra das camadas críticas. b está errado: 2 bits ingênuo em tudo destruiria math/tools — o truque é justamente não esmagar tudo igual. c contradiz a premissa do curso: o DS4 roda local, offline, a $0/token. d é falso: são 284 B de parâmetros, um modelo enorme — o que é pequeno é a fração ativa por token (Lição 03), não o total.
💬 Travou em algo? Eu sou seu professor neste curso — pergunte. "Por que 8 bits e não 4 nas camadas críticas?", "Como meço o KV cache do meu modelo?", "E se eu usar o M4 Max de 36 GB junto?". É só dizer.