A mesma ideia, um nível abaixo

Você já fez isso uma vez. O curso de pgvector guardou embeddings como halfvec para cortar o índice pela metade, e como um bit por dimensão numa busca de primeira passada. Nos dois casos, um pouco de acurácia virou muita memória economizada.

A quantização de pesos de modelo é a mesma troca, feita no próprio modelo. O que encolhe são os parâmetros, não os seus vetores. E o ganho não é um índice menor: é o modelo rodar ou não num hardware que você consegue pagar.

Por que isso decide tudo

Para rodar, os pesos de um modelo precisam estar na memória. O assunto inteiro cabe nessa frase:

Um modelo de 70 bilhões de parâmetros:
  floats de 32 bits    70B × 4 bytes    =  280 GB
  floats de 16 bits    70B × 2 bytes    =  140 GB
  inteiros de 8 bits   70B × 1 byte     =   70 GB
  inteiros de 4 bits   70B × 0,5 byte   =   35 GB

Leia essa coluna como uma lista de máquinas diferentes, e não como uma curva de custo. Com 140 GB você precisa de hardware de data center: dois aceleradores de 80 GB, ou um dos modelos mais novos, com mais memória que isso. Com 35 GB o mesmo modelo cabe numa única placa de workstation de 48 GB, ou em duas placas de consumidor de 24 GB (a maior placa de consumidor hoje tem 32 GB). É a diferença entre um servidor alugado e uma estação de trabalho, e muitas vezes entre o projeto sair do papel ou não.

Descer para quatro bits reduz a memória em cerca de 75%. É isso que transforma "precisa de um servidor com várias GPUs" em "roda numa placa só".

O que é quantização

Um peso é um número como 0,0293841. Guardado como float de 32 bits, ocupa quatro bytes e tem muito mais precisão do que o comportamento do modelo exige.

A quantização guarda esse número em menos bits, mapeando uma faixa de valores reais para um conjunto pequeno de inteiros:

pesos float32     -0,42 ... 0,38     (4 bytes cada, ~4 bilhões de valores distintos)
int8 quantizado   0 ... 255          (1 byte cada, 256 valores distintos)

flowchart LR
  V["Vetores de embedding"] --> H["halfvec, binário"] --> S1["Índice menor"]
  W["Pesos do modelo"] --> Q["INT8, INT4"] --> S2["Modelo cabe no hardware"]

O mapeamento é pura aritmética, uma escala e um deslocamento, e a aula 4 faz a conta passo a passo. O que importa aqui é que ele é com perda e estruturado: a precisão some dentro de uma faixa que você escolheu, e não de forma arbitrária.

Por que funciona

Não é óbvio que jogar fora a maior parte da precisão de um número deixe o modelo intacto. Há três motivos para que, em boa medida, deixe.

Primeiro, a precisão nunca sustentou nada. Os pesos foram treinados com ruído por todo lado: dropout, lotes, gradientes estocásticos. Um modelo que dependesse da oitava casa decimal de um peso não teria sobrevivido ao treino.

Segundo, os erros são muitos e pequenos. O erro de quantização de cada peso é minúsculo e mais ou menos independente dos outros. Somados ao longo de bilhões de pesos, os efeitos tendem a se cancelar em vez de se acumular.

Terceiro, como nos embeddings, o comportamento do modelo depende das relações entre os valores. Escalar tudo da mesma forma preserva essas relações.

Os mesmos três pontos explicam por que a quantização falha quando falha: alguns poucos pesos que sustentam algo de verdade, erros que deixam de ser independentes e faixas distorcidas por outliers. A aula 4 trata disso.

Onde isso se aplica a você

São duas situações, e elas dão o enquadramento do curso.

Você serve um modelo de pesos abertos. A quantização é o jeito de fazê-lo caber no hardware que você tem. Formato e largura de bits são decisões suas, e você as mede.

Você chama uma API. Aí a decisão não é sua, porque o provedor serve o que serve. Mesmo assim vale entender. Parâmetros vezes bytes é o que qualquer modelo ocupa na memória, e isso explica boa parte de por que um modelo pequeno sai mais barato para servir. E no dia em que uma opção auto-hospedada aparecer, é essa a aritmética que decide.

O que este curso cobre

1. A mesma ideia, um nível abaixo (você está aqui).
2. A aritmética: o que cabe.
3. Formatos de precisão, e onde a qualidade despenca.
4. Como a quantização funciona, e como ela quebra.
5. Métodos e formatos: GPTQ, AWQ, GGUF e os outros.
6. Medindo a perda com honestidade.
7. Juntando tudo: escolher, servir e decidir.

Pontos-chave

• Quantização de pesos é a mesma troca de halfvec e dos vetores binários, aplicada ao modelo em vez do seu índice.
• Pesos precisam estar na memória para rodar, então bits por parâmetro decide qual hardware consegue servir um modelo.
• Quatro bits cortam a memória em cerca de 75%, o que muitas vezes troca uma exigência de várias GPUs por uma placa só.
• Funciona porque os pesos treinados nunca dependeram dessa precisão, os erros são pequenos e independentes, e as relações entre valores sobrevivem.
• Importa diretamente quando você auto-hospeda, e indiretamente quando chama uma API: a memória de cada modelo é boa parte do custo de servi-lo.