{
  "$type": "site.standard.document",
  "bskyPostRef": {
    "cid": "bafyreifrzdjwtypdta2l4xofv4gblgr6kotixnl7y7qzutxkyguq72z4eq",
    "uri": "at://did:plc:3pjw65epwlo3rzajhx6xg4br/app.bsky.feed.post/3mkyszmaqqk32"
  },
  "coverImage": {
    "$type": "blob",
    "ref": {
      "$link": "bafkreiaus7j6xxg6uo6r5ecbqoi5afu3qsbfi5guii46h55db5m2xbr2dq"
    },
    "mimeType": "image/png",
    "size": 360104
  },
  "path": "/2026/05/03/auto-round-estado-da-arte-em-quantizacao-para-cpu-xpu-cuda/",
  "publishedAt": "2026-05-03T23:30:24.000Z",
  "site": "https://assuntonerd.com.br",
  "tags": [
    "https://github.com/intel/auto-round",
    "https://arxiv.org/html/2309.05516v3"
  ],
  "textContent": "O **AutoRound** (https://github.com/intel/auto-round) é uma ferramenta de quantização para **LLMs e VLMs** desenvolvida pela Intel. A ideia central é reduzir o modelo para **2, 3, 4 ou 8 bits** , mantendo boa precisão, principalmente em cenários de **low-bit weight-only quantization** (converte os pesos mas manter a inferência), como `W4A16`, `W3A16` e `W2A16`. O próprio repositório descreve o AutoRound como um toolkit para LLMs/VLMs que usa **signed gradient descent** para obter alta acurácia em 2–4 bits com baixo custo de ajuste.\n\n> Como**Intel Innovator,** tenho a missão mostrar o compromisso sério da Intel neste vertical tecnológica. A tecnologia beneficia GPU NVIDIA, CPU e XPU\n\nEm termos simples: ele não apenas “arredonda” os pesos para 4 bits como um método ingênuo faria. Ele **aprende a melhor forma de arredondar os pesos** e também ajusta os limites de clipping para reduzir o erro entre a saída do bloco original e a saída do bloco quantizado. O paper do SignRound (https://arxiv.org/html/2309.05516v3) explica que o método adiciona parâmetros treináveis para ajustar o rounding e dois parâmetros extras para ajustar o clipping dos pesos; depois usa reconstrução por bloco e otimização com SignSGD.\n\n## Como ele funciona\n\nO fluxo é mais ou menos assim:\n\n  1. Você passa um modelo Hugging Face, por exemplo `Qwen/Qwen3-0.6B`, `Llama`, `Mistral`, etc.\n  2. Ele usa um dataset de calibração. Por padrão, usa `NeelNanda/pile-10k`, mas aceita datasets customizados, JSON local, lista de strings, input ids, concatenação de datasets e aplicação de chat template.\n  3. Para cada bloco/camada, ele compara a saída do modelo original com a saída do modelo quantizado.\n  4. Ele otimiza o **rounding dos pesos** e o **range de clipping** usando signed gradient descent.\n  5. No final, salva o modelo em um formato escolhido: `auto_round`, `auto_gptq`, `auto_awq`, `gguf`, `llm_compressor`, `mlx`, entre outros.\n\n\n\n## Como usar?\n\n`pip install auto-round\nauto-round \\\n--model Qwen/Qwen3-0.6B \\\n--scheme \"W4A16\" \\\n--format \"auto_round\" \\\n--output_dir ./qwen_autoround_w4a16`\n\nPara exportar para GGUF:\n\n`auto-round \\\n--model Qwen/Qwen3-0.6B \\\n--format \"gguf:q4_k_m\" \\\n--output_dir ./qwen_gguf_q4_k_m`\n\nO repositório mostra instalação via `pip install auto-round`, suporte a CPU/GPU CUDA, Intel XPU e Gaudi/HPU, além de exemplos com `Qwen/Qwen3-0.6B`\n\n## O que significa W4A16, W3A16, W2A16\n\n`W4A16` significa:\n\nCampo | Significado\n---|---\n`W4` | pesos em 4 bits\n`A16` | ativações em 16 bits, normalmente FP16/BF16\n`group_size=128` | quantização por grupos de pesos\n`sym=True` | quantização simétrica\n\nO AutoRound documenta esquemas como `W4A16`, `W8A16`, `W3A16`, `W2A16`, mixed bits, GGUF, NVFP4, MXFP4, FP8 e outros.\n\nNa prática, `W4A16` costuma ser o ponto mais seguro: boa redução de memória com perda pequena. `W2A16` é muito mais agressivo: pode reduzir muito mais o tamanho dos pesos, mas exige algoritmo melhor, calibração melhor e validação forte.\n\n## Diferença para GPTQ, AWQ, SmoothQuant, bitsandbytes e GGUF\n\nTecnologia | O que faz | Diferença principal em relação ao AutoRound\n---|---|---\n**AutoRound / SignRound** | PTQ weight-only com otimização de rounding e clipping por SignSGD | Mais focado em **otimizar o arredondamento** dos pesos, bom para 2–4 bits, com exportação para vários formatos\n**GPTQ** | Quantização weight-only baseada em informação de segunda ordem/Hessian | GPTQ é “one-shot” e muito usado para 3/4 bits; AutoRound usa otimização de rounding/clipping e pode inclusive exportar em formato GPTQ\n**AWQ** | Activation-aware weight quantization | AWQ identifica canais importantes pelas ativações e protege pesos salientes; não depende de backprop/reconstrução, enquanto AutoRound otimiza com calibração e SignSGD\n**SmoothQuant** | Quantização W8A8, pesos e ativações em INT8 | SmoothQuant é mais voltado para INT8 completo, migrando dificuldade das ativações para os pesos; AutoRound é mais focado em weight-only low-bit, como W4A16/W2A16\n**bitsandbytes / QLoRA** | Quantização 8-bit/4-bit prática para carregar e fine-tunar modelos | bitsandbytes é ótimo para fine-tuning com LoRA/QLoRA e carregamento simples; AutoRound é mais um pipeline offline de quantização calibrada/exportável\n**GGUF / llama.cpp** | Formato/ecossistema de arquivo e kernels para CPU/GPU | GGUF não é apenas algoritmo; é formato + tipos de quantização. AutoRound pode exportar para GGUF, inclusive `q4_k_m`, `q2_k_s`, etc.\n\nGPTQ se baseia em quantização weight-only com informação aproximada de segunda ordem e mostrou bons resultados em 3/4 bits em modelos grandes. AWQ usa estatísticas de ativação para proteger canais salientes e evitar quantização mista ineficiente, sem backpropagation ou reconstrução. SmoothQuant é uma abordagem PTQ para `W8A8`, suavizando outliers de ativação por uma transformação matematicamente equivalente entre ativações e pesos. bitsandbytes fornece camadas quantizadas 8-bit/4-bit, otimizadores 8-bit, `LLM.int8()` e QLoRA com NF4 para reduzir uso de memória.\n\n## Vantagens do AutoRound\n\nA grande vantagem é que ele tenta entregar **mais qualidade em baixa precisão** , principalmente em **2, 3, 4 e 8 bits** , onde métodos simples como RTN geralmente degradam bastante. No paper original, os autores comparam com GPTQ, AWQ, HQQ, OmniQuant e RTN, e relatam ganhos maiores conforme os bits diminuem, especialmente em `W2G128`, com melhorias absolutas de acurácia média entre 6,91% e 33,22% em 11 tarefas zero-shot.\n\nOutra vantagem é a **compatibilidade de ecossistema** : o AutoRound suporta exportação para `auto_round`, `auto_gptq`, `auto_awq`, `gguf`, `llm_compressor` e `mlx`, além de integração com Transformers, vLLM e SGLang.\n\n## Dicas:\n\n`# equilíbrio entre qualidade e custo\nauto-round --model Qwen/Qwen3-0.6B --scheme \"W4A16\"\n# melhor qualidade, mais lento\nauto-round-best --model Qwen/Qwen3-0.6B --scheme \"W4A16\"\n# mais rápido, com possível perda de acurácia\nauto-round-light --model Qwen/Qwen3-0.6B --scheme \"W4A16\"`\n\nA documentação recomenda `auto-round` como bom equilíbrio geral, `auto-round-best` para melhor acurácia — especialmente 2-bit — e `auto-round-light` para velocidade, mais indicado em 4-bit e modelos maiores que 3B.\n\nO AutoRound não elimina a necessidade de **benchmark real**. Quantização muda o comportamento do modelo, e a perda pode aparecer em raciocínio, código, português, instruções longas ou domínios específicos. Para um modelo que você usa em produção, eu validaria pelo menos:\n\n`# exemplo conceitual\nlm_eval \\\n--model hf \\\n--model_args pretrained=./qwen_autoround_w4a16 \\\n--tasks hellaswag,arc_challenge,mmlu,truthfulqa \\\n--batch_size auto`\n\nTambém é importante entender que `W4A16` quantiza principalmente os **pesos** , mantendo ativações em 16 bits. Isso reduz muito o tamanho do modelo, mas não resolve sozinho todos os gargalos, por exemplo KV-cache em contextos longos. O paper original deixa claro que o foco experimental era weight-only quantization em camadas lineares dos blocos transformer.\n\nOutro ponto: alguns esquemas novos, como MXFP4/MXINT4/MXFP8, aparecem na documentação como recursos de pesquisa ou sem kernel real em certos casos; então o formato escolhido precisa casar com o runtime que você vai usar.\n\nMinha leitura particular: **AutoRound é uma das opções mais interessantes hoje para quantização low-bit de LLMs quando qualidade importa mais do que apenas velocidade de conversão**. Para `W4A16`, eu testaria como alternativa séria a GPTQ/AWQ. Para `W2A16`, eu priorizaria AutoRound/SignRound, mas sempre com avaliação no seu conjunto de tarefas.\n\nCódigo fonte: https://github.com/intel/auto-round",
  "title": "auto-round: Estado da Arte em quantização para CPU/XPU/GPU NVIDIA"
}