BroadRouter
Começar

Quantização (quantization)

Atualizado em

Quantização é o processo de armazenar os números de uma rede neural, principalmente os pesos, em um formato de menor precisão, como 8 ou 4 bits em vez de 16 bits, para que o modelo use menos memória e muitas vezes rode mais rápido. Bons métodos mantêm pequena a perda de precisão.

Também chamado de: quantização, quantização de modelos, quantização de LLM, modelo quantizado, quantização de pesos, quantization, model quantization, LLM quantization, quantized model, weight quantization

A maioria dos modelos abertos é distribuída com pesos de 16 bits. A quantização encolhe esses números para que o modelo caiba em menos GPUs.

Como funciona

O Hugging Face descreve a quantização como “representing weights and activations with lower-precision data types like 8-bit integers (int8)” (tradução: representar pesos e ativações com tipos de dados de menor precisão, como inteiros de 8 bits, int8). Cada bloco de pesos recebe um fator de escala. Os pesos são arredondados para um pequeno conjunto de níveis e multiplicados de volta pela escala na hora da execução.

A memória dos pesos acompanha os bits por parâmetro. Veja o Gemma 4 26B A4B do Google, que tem 25,2B de parâmetros:

Precisão Bytes por peso Só os pesos
16 bits (BF16) 2 25,2B × 2 = 50,4 GB
8 bits (FP8 ou INT8) 1 25,2 GB
4 bits (INT4) 0,5 12,6 GB

O KV cache e as ativações precisam de espaço além disso.

Os métodos diferem no que quantizam e em como escolhem os níveis:

  • LLM.int8() corta pela metade a memória de inferência e mantém algumas features atípicas (outliers) em 16 bits; o artigo diz que mais de 99,9% dos valores continuam usando contas em 8 bits.
  • GPTQ é um método one-shot para pesos que chega a 3 ou 4 bits por peso com “negligible accuracy degradation” (tradução: degradação de precisão desprezível) e quantiza um modelo de 175B em cerca de quatro horas de GPU.
  • Só pesos ou pesos e ativações. Formatos só de pesos economizam memória. Quantizar também as ativações pode acelerar as contas de matriz em hardware que suporte isso.

Por que isso importa

Para quem chama uma API, a quantização é invisível na requisição, mas aparece em três lugares. Preço: modelos menores precisam de menos GPUs, o que reduz o custo de serving. Velocidade: a geração costuma ser limitada pela largura de banda de memória, então menos bytes por peso podem significar mais tokens por segundo. Qualidade: menos bits significam mais erro de arredondamento, e um modelo pode manter a nota média enquanto piora justamente nas tarefas de que você depende.

Se você compara dois provedores servindo o “mesmo” modelo aberto e obtém resultados diferentes, a precisão é uma causa provável.

Na BroadNet Inference

A referência da API da BroadNet não informa a precisão de serving. O catálogo de modelos dela lista o build de produção do Gemma 4 26B A4B, oferecido como BroadNet Gemma 4 VL 26B, com pesos AWQ de 4 bits e KV cache em FP8. Ele não informa a precisão na API dos outros modelos. Se a precisão importa para o seu uso, rode o mesmo conjunto de avaliação em cada provedor; o checklist para avaliar um modelo antes de trocar mostra como.

Perguntas frequentes

A quantização piora o modelo?

Às vezes, um pouco. O LLM.int8() relata nenhuma degradação na inferência em 8 bits até 175B de parâmetros, e o GPTQ relata perda desprezível com 3 ou 4 bits por peso. Menos bits e tarefas mais difíceis aumentam o risco, então teste com os seus próprios prompts.

Dá para saber se uma API serve um modelo quantizado?

Normalmente só se o provedor disser. A API devolve o mesmo formato de resposta nos dois casos, então compare as saídas nos seus testes e pergunte ao provedor qual precisão ele usa.

Quanta memória a quantização economiza?

A memória dos pesos acompanha os bits por peso. Um modelo de 25,2B de parâmetros precisa de cerca de 50,4 GB em 16 bits, 25,2 GB em 8 bits e 12,6 GB em 4 bits, antes do KV cache e das ativações.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity