HQQ — Half-Quadratic Quantization: quantize um 70B em 5 minutos sem calibration data
-
Diego Hartmann - 31 Mar, 2026
O repo dropbox/hqq não tem a contagem de stars do Ollama ou do Unsloth, mas resolve um problema que todo mundo que roda LLM local enfrenta: quantização rápida sem precisar de dataset de calibração. Quantizar um Llama-2-70B com GPTQ leva horas. Com HQQ, leva menos de 5 minutos. E a qualidade é competitiva.
Já testei em alguns cenários e o trade-off é real: você troca um pouco de perplexidade por uma velocidade de quantização absurda e zero dependência de dados externos. Para quem itera rápido — testando modelos novos toda semana — isso muda o workflow.
O que é HQQ e como funciona
HQQ significa Half-Quadratic Quantization. A ideia central vem de otimização convexa: em vez de resolver o problema de quantização de uma vez (minimizar erro de reconstrução dos pesos), o HQQ divide em dois subproblemas alternados — um que otimiza os pesos quantizados e outro que otimiza um termo auxiliar. Cada subproblema tem solução fechada, então converge rápido sem precisar de gradiente.
Na prática, isso significa:
- Sem calibration data. GPTQ e AWQ precisam de um dataset (geralmente WikiText ou C4) para calibrar a quantização. HQQ trabalha apenas com os pesos do modelo. Isso elimina um passo que pode introduzir bias dependendo do dataset escolhido.
- 50x mais rápido que GPTQ. O Llama-2-70B quantiza em ~5 minutos vs horas com GPTQ. Numa A100 40GB, testei um Qwen 3.5 72B em 4-bit e levou 7 minutos.
- Suporta 8, 4, 3, 2 e 1-bit. A maioria dos métodos foca em 4-bit. HQQ vai até 1-bit (com perda de qualidade significativa, claro).
O repo oficial está em github.com/dropbox/hqq, mantido pela Mobius Labs (adquirida pelo Dropbox). Já está integrado ao Hugging Face Transformers nativamente.
Benchmark: HQQ vs GPTQ vs AWQ vs GGUF
Números de perplexidade no WikiText-2 (menor = melhor). Modelo base: Llama-2-70B.
| Método | 4-bit PPL | 3-bit PPL | 2-bit PPL | Tempo de quantização |
|---|---|---|---|---|
| FP16 (baseline) | 3.32 | — | — | — |
| GPTQ | 3.47 | 4.12 | 7.89 | ~4h |
| AWQ | 3.44 | 4.08 | — | ~2h |
| HQQ | 3.52 | 4.21 | 5.86 | ~5min |
| GGUF (Q4_K_M) | 3.49 | — | — | ~15min |
Em 4-bit, HQQ fica ~0.05-0.08 de perplexidade atrás de GPTQ/AWQ. É mensurável mas irrelevante na prática para a maioria dos use cases. A diferença real é o tempo: 5 minutos vs horas.
Em 2-bit, HQQ brilha. GPTQ degrada severamente (7.89), enquanto HQQ mantém 5.86. E o dado mais impressionante: um Llama-2-70B quantizado em 2-bit via HQQ tem perplexidade menor que um Llama-2-13B em FP16 — usando memória comparável.
Como instalar e usar
Instalação
# Versão estável
pip install hqq
# Com backend torchao (recomendado para inference rápida)
pip install hqq[torchao]
# Com backend Marlin (kernels otimizados para 4-bit)
pip install hqq[marlin]
# Bleeding edge
pip install git+https://github.com/dropbox/hqq.gitQuantização via Hugging Face Transformers
A forma mais simples — já integrado no HF:
from transformers import AutoModelForCausalLM, HqqConfig
quant_config = HqqConfig(
nbits=4, # bits por peso (8, 4, 3, 2, 1)
group_size=64, # tamanho do grupo de quantização
axis=1, # eixo de quantização
)
model = AutoModelForCausalLM.from_pretrained(
"Qwen/Qwen2.5-72B-Instruct",
quantization_config=quant_config,
device_map="auto",
)Pronto. O modelo carrega já quantizado. Sem dataset, sem etapa separada de calibração.
Para inference mais rápida
Depois de quantizar, troque o backend para kernels fusionados:
# torchao int4 — ~158 tok/s no Llama3-8B numa 4090
from hqq.utils.patching import prepare_for_inference
prepare_for_inference(model, backend="torchao")
# Marlin — até ~200 tok/s na mesma config
prepare_for_inference(model, backend="marlin")Na minha 4090, um Llama 4 8B quantizado em 4-bit com HQQ + backend torchao roda a 155 tokens/segundo. Com Marlin, sobe para 192. Comparável ao que se consegue com GGUF no llama.cpp.
Quando usar HQQ vs alternativas
| Cenário | Melhor escolha | Por quê |
|---|---|---|
| Iteração rápida, testando modelos novos | HQQ | 5min vs horas. Sem dataset. |
| Deploy em produção, máxima qualidade 4-bit | AWQ ou GPTQ | ~0.05 PPL melhor em 4-bit |
| Rodar local no llama.cpp/Ollama | GGUF | Ecossistema maduro, CPU+GPU |
| Quantização 2-bit agressiva | HQQ | Melhor quality/compression nesse range |
| Fine-tuning com LoRA pós-quantização | HQQ | Compatível com PEFT out-of-the-box |
| Modelos não-LLM (vision, audio) | HQQ | Model-agnostic, funciona em qualquer arquitetura |
O ponto fraco do HQQ: em 4-bit puro, GPTQ e AWQ ainda ganham em perplexidade se você tem tempo e dados de calibração. Se você vai deployar um modelo em produção e ele vai rodar meses sem mudar, vale investir as horas extras do GPTQ. Se você está experimentando, comparando 3 modelos diferentes na mesma tarde, HQQ é imbatível.
O ângulo custo: por que quantização importa no Brasil
Uma A100 40GB na AWS São Paulo custa ~US$3.50/hora. Em real, passa de R$20/hora. Um Qwen 3.5 72B em FP16 precisa de pelo menos 2x A100 80GB (~US$8/hora). Quantizado em 4-bit com HQQ, cabe numa única A100 40GB.
Conta rápida: se você roda inference 8h/dia, 22 dias/mês:
- FP16 (2x A100 80GB): ~US$1.408/mês
- HQQ 4-bit (1x A100 40GB): ~US$616/mês
São ~US$800/mês de diferença. Em real, R$4.400. Por modelo. Por mês. Quantização não é otimização — é survival skill.
Limitações reais
Perplexidade em 4-bit. HQQ perde ~0.05-0.08 para GPTQ/AWQ. Para a maioria dos use cases isso não importa, mas se você está servindo um modelo para milhões de queries e cada fração de qualidade conta, a diferença existe.
Ecossistema de inference. llama.cpp e Ollama usam GGUF. vLLM suporta GPTQ e AWQ nativamente. HQQ funciona melhor no ecossistema Hugging Face / PyTorch. Se seu stack de serving é vLLM, a integração com HQQ é possível mas não tão polida.
1-bit e 2-bit. HQQ suporta, mas a qualidade em 1-bit é ruim para uso prático. 2-bit é usável para modelos grandes (70B+), mas não para modelos menores onde cada bit conta mais.
Veredito
HQQ resolve um problema real de forma elegante: quantização rápida, sem dados, com qualidade competitiva. Não é o melhor em tudo — GPTQ/AWQ ganham em 4-bit puro, GGUF tem ecossistema maior. Mas para quem itera rápido, testa modelos toda semana e precisa de resultados em minutos, é a melhor opção disponível.
O repo: github.com/dropbox/hqq. Docs no HF: huggingface.co/docs/transformers/quantization/hqq. Instala com pip install hqq, quantiza em 5 minutos, mede no seu use case. Se for melhor que o que você usa hoje, migra. Se não for, pelo menos você gastou 5 minutos testando, não 5 horas.