bestmodel.run / blog

GLM-5.3 cheio vs Flash em 4×B300: quantos tok/s antes de alugar

A pergunta veio de uma conversa com o Fabio Akita: vale alugar 4×B300 (4 × 288 GB, ~1,1 TB usável) para rodar o GLM-5.3 cheio, ou o GLM-5.3-Flash no mesmo hardware entrega quase tudo, bem mais rápido? Ninguém no pool mediu B300 ainda. Então esta página é modelada, não medida — e diz exatamente de onde vem cada número. A versão interativa (troque GPU, quantidade e contexto) está em /planejar.

Resposta curta

Com 1 usuário, 212k de contexto, sem MTP:

Modelo Quant Cabe em 4×B300? tok/s (mid, faixa) com MTP TTFT 212k
GLM-5.3 cheio BF16 não (1.516 GB) – – –
GLM-5.3 cheio FP8 sim (769 GB) 112 (84–157) 220 (133–371) ~3 s
GLM-5.3 cheio NVFP4 sim (434 GB) 122 (90–177) 240 (142–420) ~3 s
GLM-5.3 cheio EXL3 3,5 bpw sim (340 GB) 125 (92–184) 247 (145–436) ~3 s
GLM-5.3 cheio GGUF Q4_K_M (llama.cpp) sim (467 GB) 88 (66–104) 174 (105–247) ~3 s
Flash FP8 sim (324 GB) 202 (151–288) 395 (236–677) ~1,3 s
Flash NVFP4 sim (182 GB) 216 (159–319) 423 (249–749) ~1,3 s
Flash EXL3 3,5 bpw sim (142 GB) 221 (161–329) 432 (253–772) ~1,3 s
Flash GGUF Q4_K_M (llama.cpp) sim (196 GB) 166 (122–199) 325 (191–467) ~1,3 s

O Flash fica ~1,8× mais rápido no FP8 e no NVFP4. É bastante, mas é menos do que a razão de parâmetros ativos (40B vs 18B = 2,2×) sugere — e o motivo é a parte interessante.

Por que não é 2,2×

Em batch 1, cada token gerado lê os pesos ativos uma vez. Em 4×B300 isso é rápido demais para importar: 40B em FP8 são 10 GB por GPU, lidos a ~6 TB/s efetivos — 1,7 ms. O que domina é o custo fixo de cada camada (lançamento de kernels, all-reduce entre GPUs, roteamento do MoE): algo entre 60 e 130 µs por camada. O GLM-5.3 tem 78 camadas; o Flash, 45. Isso dá 4,7–10 ms contra 2,7–5,9 ms por token.

Ou seja: nesse hardware a diferença de velocidade vem mais da profundidade do modelo do que do número de parâmetros ativos. Quantizar mais agressivo (NVFP4, 3,5 bpw) quase não muda nada no cheio: o termo de banda já é pequeno. Quantização agressiva aqui serve para caber e sobrar memória para mais usuários, não para ficar mais rápido sozinho.

Duas consequências práticas:

  • MTP/speculative decoding é a alavanca real. Os dois modelos trazem 1 camada MTP. Com aceite de 1,6–2,4 tokens por passo, praticamente dobra o tok/s — muito mais do que trocar FP8 por NVFP4.
  • llama.cpp com split por camada é pior aqui. Só uma GPU lê pesos por vez, então a banda não soma; nas medições do pool ele ainda paga custo por camada parecido com o do vLLM.

E os 212k de contexto?

Quase não pesam no decode. Os dois modelos usam atenção esparsa (DSA): cada passo lê só os 2.048 tokens mais relevantes, mais as chaves pequenas do indexador. A 212k isso é ~0,6 GB lidos por passo no cheio — 0,03 ms. O KV cache inteiro de 212k cabe em ~10 GB no cheio e ~1,7 GB no Flash (KV em FP8).

O contexto pesa no TTFT: processar 212k de prompt leva ~3 s no cheio e ~1,3 s no Flash, assumindo 40% de utilização do FP8 denso.

De onde vem o número

O modelo é física de banda de memória mais um custo fixo por camada:

t_token = pesos_ativos / (banda × 0,75 × GPUs) + KV_lido / banda + camadas × custo_por_camada

O custo por camada foi calibrado em medições reais, e o teste do repo garante que a fórmula reproduz cada uma dentro da faixa:

Âncora Medido
GLM-5.2 NVFP4 (mesma base de 78 camadas do 5.3), 4×RTX PRO 6000, vLLM, pool n=3 86,8 tok/s
GLM-5.3-Flash ~3 bits, 2×RTX PRO 6000, vLLM, pool n=8 149,7 tok/s
GLM-5.3-Flash NVFP4, 8×B200 TP8/EP8, card da Blackfrost ~165 tok/s
GLM-5.2 GGUF ~Q4, 4×RTX PRO 6000, llama.cpp, pool n=2 39,7 tok/s

Specs: GLM-5.3 com 78 camadas, MLA (kv_lora_rank 512), indexador top-2048, ~753B total / ~40B ativos; GLM-5.3-Flash com 45 camadas (11 DSA + 34 de atenção linear), 320B / 18B; B300 com 288 GB HBM3e, 8 TB/s e 5 PFLOPS FP8 denso.

O que isto não é

Não é medição. A maior incerteza é justamente o custo por camada em NVLink com TP4 — as âncoras são PCIe e um TP8 em B200. Se você alugar o rig, rode o console e envie: a primeira célula medida substitui esta estimativa no pool.