A quantização em IA é uma técnica de compressão que armazena os pesos de um modelo, e às vezes suas ativações, em menos bits para que ele precise de menos memória. Ao passar de pesos de 16 bits para quantização de 8 ou 4 bits, um modelo de 8B cai de cerca de 16GB para cerca de 8GB ou 4–5GB apenas para os pesos, trocando um pouco de precisão por uma ocupação menor.
Quando analiso cartões de modelos para implantação local, as mesmas etiquetas aparecem repetidamente: 8 bits, 4 bits, GPTQ, AWQ e GGUF. Cada uma se refere a uma forma diferente de representar números em uma rede neural para que o modelo caiba em uma única GPU, em um notebook ou em uma instância de servidor menor.
Como a quantização de modelos reduz a memória?
A quantização de modelos reduz a memória ao diminuir o número de bits atribuídos a cada parâmetro nas matrizes de pesos de um modelo. Em novembro de 2026, a visão geral de quantização da Hugging Face observa que os modelos geralmente são carregados em bf16, que usa 2 bytes por parâmetro. Pela regra prática da Hugging Face para apenas os pesos, um modelo de 8B parâmetros precisa de cerca de 16GB para seus pesos em bf16, cerca de 8GB em 8 bits e cerca de 4–5GB em 4 bits.
Esse exemplo de 8B é uma regra prática para apenas os pesos, e não um orçamento completo de VRAM para executar inferência. A memória real de atendimento também inclui ativações, sobrecarga de execução e o cache de chave-valor que guarda o histórico de atenção ao longo do prompt e da saída. Se você pretende atender contextos longos, nosso guia sobre o que é um cache KV explica por que a memória cresce com o comprimento da sequência.
Pela aritmética básica de armazenamento, cada redução na largura em bits diminui os bytes brutos necessários por parâmetro:
| Formato de precisão | Armazenamento por parâmetro (cálculo) | Ocupação relativa dos pesos em relação a BF16 |
|---|---|---|
| FP32 | 4 bytes | 2x |
| FP16 / BF16 | 2 bytes | 1x |
| FP8 / INT8 | 1 byte | 0.5x |
| FP4 / INT4 / 4 bits no estilo NVFP4 | 0.5 bytes | 0.25x (mais a sobrecarga do formato) |
Essas quantidades de bytes descrevem o cálculo bruto de armazenamento, não um benchmark de tempo real ou qualidade de saída. Mantidas as demais condições, passar de BF16 para 8 bits reduz pela metade a memória dos pesos, enquanto passar de BF16 para 4 bits a reduz a aproximadamente um quarto. A faixa de 4–5GB em um modelo de 8B considera metadados de quantização e sobrecarga do formato. Como afirma a Hugging Face, menos bits custam um pouco de precisão, e cada método de quantização faz uma troca diferente entre memória, velocidade e precisão.
Duas maneiras de carregar modelos quantizados na prática
Checkpoints quantizados entram em um pipeline de inferência ou ajuste fino por dois processos distintos de carregamento, dependendo de a compressão ocorrer durante o carregamento ou antecipadamente.
- Quantizar um checkpoint de precisão completa durante o carregamento. No Hugging Face Transformers, você passa um objeto de configuração de quantização para
from_pretrainedjunto com um checkpoint padrão. Por exemplo, a documentação oficial mostra como carregarmeta-llama/Llama-3.1-8B-Instructem 4 bits passandoBitsAndBytesConfig(load_in_4bit=True, ...). A maioria dos métodos durante o carregamento dispensa dados de calibração, mas GPTQ é a exceção, pois se calibra em um conjunto de dados enquanto o modelo é carregado. - Carregar um checkpoint já quantizado. Quando um checkpoint já foi comprimido e salvo, você o carrega sem passar uma nova configuração de quantização. O Transformers lê os detalhes da quantização no arquivo
config.jsondo repositório ou em um arquivo GGUF indicado pelo nome. Métodos como AWQ, AutoRound, AQLM,compressed-tensorse GGUF só oferecem suporte a esse processo no Transformers: você começa com um checkpoint quantizado previamente com a biblioteca própria do método. É assim que muitas versões dos modelos de pesos abertos em 2026 são distribuídas.
Métodos comuns de quantização: bitsandbytes, GPTQ, AWQ e GGUF
Os métodos comuns de quantização de modelos diferem quanto ao momento da compressão, às larguras em bits e ao hardware compatíveis e ao foco em pipelines do Transformers ou em runtimes locais independentes.
| Método / formato | Processo no Transformers | Larguras em bits / tipo numérico | Hardware na documentação da HF | Principal observação operacional |
|---|---|---|---|---|
| bitsandbytes | Quantizar ao carregar ou carregar salvo | 4 bits e 8 bits | CUDA, XPU, HPU, CPU | Sem calibração; aceita ajuste fino |
| GPTQ | Pré-quantizado ou calibrar ao carregar | 4 bits (de int4 para fp16 durante a execução) |
CUDA, XPU, CPU | Precisa de conjunto de calibração; use GPT-QModel |
| AWQ | Somente pré-quantizado | 4 bits | CUDA, XPU, CPU | Preserva pesos importantes por meio das ativações |
| GGUF | Somente pré-quantizado (gguf_file) |
De 1 a 8 bits | CUDA, MPS, XPU, CPU | Arquivo único; padrão no llama.cpp e Ollama |
| NVFP4 / FP8 de granularidade fina | Quantizar ao carregar (específico do hardware) | Ponto flutuante de 4 / 8 bits | GPUs NVIDIA (NVFP4 em Blackwell) | Representação de ponto flutuante |
bitsandbytes
O guia de seleção de métodos da Hugging Face recomenda bitsandbytes quando você quer fazer um modelo caber em menos memória com o mínimo de configuração. Ele quantiza para 4 ou 8 bits durante o carregamento sem conjunto de calibração, funciona em CUDA, XPU, HPU e CPU e permite tanto salvar quanto fazer ajuste fino. Segundo a documentação do bitsandbytes, o modo de 8 bits usa LLM.int8() e reduz pela metade a memória dos pesos. O modo de 4 bits viabiliza QLoRA, que comprime os pesos para 4 bits e mantém o modelo treinável ao inserir um pequeno conjunto de pesos treináveis de adaptação de baixo posto (LoRA).
GPTQ
GPTQ é um método de quantização pós-treinamento que comprime cada linha de uma matriz de pesos independentemente para minimizar o erro de reconstrução. Segundo a documentação de GPTQ da Hugging Face, os pesos são quantizados para int4 e restaurados para fp16 durante a inferência. Isso pode reduzir o uso de memória em 4 vezes porque os pesos int4 são desquantizados em um kernel fundido, em vez da memória global da GPU; larguras menores em bits também levam menos tempo para serem comunicadas. A quantização GPTQ exige um conjunto de calibração e um tokenizador, como em GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer) na documentação. O Transformers não aceita mais AutoGPTQ e encaminha os usuários para GPT-QModel.
AWQ
AWQ, abreviação de Activation-aware Weight Quantization, concentra-se em proteger o pequeno subconjunto de pesos mais importante para a qualidade da saída. Como explica a documentação de AWQ da Hugging Face, AWQ preserva uma pequena fração dos pesos importantes para o desempenho do LLM para comprimir um modelo a 4 bits com degradação mínima do desempenho. No Transformers, AWQ é apenas pré-quantizado e carrega checkpoints criados com llm-awq ou autoawq.
GGUF
GGUF é um formato de arquivo único que reúne pesos, configuração e tokenizador de um modelo em um arquivo, em vez de usar um config.json separado. Por isso, o Transformers exige um argumento gguf_file explícito. Em ferramentas locais como llama.cpp e Ollama, GGUF é o formato por trás de nomes de arquivos com etiquetas como Q4_K_M, com suporte a pesos pré-quantizados de 1 a 8 bits em CUDA, MPS, XPU e CPU.
Uma ressalva importante aplica-se especificamente ao Transformers: a Hugging Face observa que a maioria dos modelos GGUF é desquantizada para precisão completa ao ser carregada no Transformers, usando tanta memória quanto um modelo não quantizado, exceto por uma possibilidade restrita que usa MPS e kernels em alguns modelos Qwen3.5. Esse comportamento pertence ao carregador GGUF do Transformers; runtimes locais como llama.cpp e Ollama foram feitos para executar diretamente pesos GGUF quantizados.
Formatos de ponto flutuante de poucos bits: FP8, NVFP4 e MXFP8
A quantização de poucos bits também se aplica a formatos de ponto flutuante, diferentes dos formatos inteiros como INT8 e INT4. O guia de seleção da Hugging Face lista FP8 de granularidade fina, MXFP4 e NVFP4, que quantiza para o formato de ponto flutuante de 4 bits da NVIDIA em GPUs Blackwell durante o carregamento. Existem dezenas de outros esquemas, incluindo torchao, HQQ e compressed-tensors, todos catalogados no guia de seleção do Transformers.
Qual é a diferença entre quantização apenas dos pesos e quantização completa?
A quantização apenas dos pesos comprime as matrizes de parâmetros armazenadas e mantém as ativações e o cache KV em precisão maior, a menos que esses componentes sejam quantizados separadamente. Muitos pipelines populares de inferência GGUF de 4 bits e de quantização apenas dos pesos armazenam pesos de largura reduzida na memória e desquantizam ou calculam multiplicações de matrizes em um formato mais amplo.
Durante a geração de textos longos, as ativações e o cache KV continuam consumindo RAM da GPU ou do sistema junto com os pesos. A Hugging Face documenta a quantização do cache KV como uma etapa separada de otimização para sequências longas. A arquitetura também determina a memória total: mesmo nos projetos esparsos abordados em nossa explicação sobre Mixture of Experts, todos os especialistas roteados e compartilhados precisam estar na memória, embora apenas uma fração seja executada por token.
Como a quantização pós-treinamento difere do treinamento nativo de poucos bits?
A quantização pós-treinamento começa com um checkpoint concluído de alta precisão e o comprime depois, enquanto o treinamento nativo de poucos bits treina e implanta o modelo diretamente em formatos numéricos de poucos bits. GPTQ, AWQ, a maioria das conversões GGUF e bitsandbytes durante o carregamento pertencem à categoria pós-treinamento, aceitando algum erro de conversão depois que o pré-treinamento e o alinhamento terminam.
O treinamento nativo de poucos bits elimina essa etapa de conversão posterior. Um exemplo atual é o Inkling 2 Mini, lançado pela Thinking Machines Lab em 20 de novembro de 2026. Segundo o anúncio oficial do Inkling 2 Mini e o cartão do modelo, o modelo de 26.4B parâmetros ocupa aproximadamente 20GB de memória e foi treinado com NVFP4 de 4 bits nas camadas de especialistas em todas as passagens diretas, do pré-treinamento ao aprendizado por reforço, além de MXFP8 de 8 bits nas passagens diretas das últimas quatro camadas.
A Thinking Machines Lab afirma que os pesos do Inkling 2 Mini são implantados na mesma precisão numérica em que foram treinados — 20 camadas em NVFP4 e 4 em MXFP8 —, portanto não há perda de conversão por quantização. Isso significa que não há perda de precisão pela conversão de um checkpoint BF16 concluído para 4 bits após o treinamento; não é uma comparação com um gêmeo BF16 separado. As orientações de hardware da equipe recomendam Apple silicon com 32GB ou mais de memória, GPUs com 32GB ou mais de VRAM ou um único NVIDIA DGX Spark.
Qual abordagem de quantização combina com seu fluxo de trabalho?
A escolha de um método depende do runtime, do hardware e de você precisar fazer ajuste fino ou apenas executar inferência. Como cada método equilibra memória, velocidade e precisão de modo diferente conforme a tarefa, nenhuma largura em bits serve para toda carga de trabalho.
- Escolha bitsandbytes quando quiser carregar um checkpoint existente de precisão completa em 4 ou 8 bits com configuração mínima, ou quando planejar fazer ajuste fino com QLoRA.
- Escolha GPTQ ou AWQ quando quiser um checkpoint de 4 bits já calibrado ou que considere ativações, feito para inferência.
- Escolha GGUF quando quiser um checkpoint portátil de arquivo único para runtimes locais como
llama.cppou Ollama. - Escolha checkpoints nativos de poucos bits quando um desenvolvedor fornecer pesos treinados diretamente em NVFP4, FP8 ou MXFP8.
Sempre verifique a licença do modelo antes de converter ou redistribuir pesos quantizados e deixe uma margem de memória para o cache KV e a sobrecarga do runtime. Se seu objetivo for reduzir os custos de inferência na nuvem, em vez de fazer os pesos caberem em hardware local, veja as estratégias de prompt e roteamento em nosso guia sobre como reduzir custos de API de IA.
FAQ
A quantização de 4 bits sempre reduz a qualidade de forma perceptível?
Nenhuma regra prevê o impacto exato da quantização de 4 bits na qualidade para todos os modelos e tarefas. Segundo a documentação de quantização da Hugging Face, menos bits custam um pouco de precisão e cada método oferece uma troca diferente entre memória, velocidade e precisão. Métodos como AWQ e GPTQ procuram limitar o erro considerando ativações ou usando calibração, enquanto largura em bits, arquitetura do modelo e carga de trabalho também influenciam o resultado.
Por que um modelo de 8B em 4 bits precisa de mais de 4–5GB de VRAM total?
O valor de 4–5GB para um modelo de 8B em 4 bits é uma regra prática da Hugging Face para apenas os pesos, não um orçamento completo de atendimento. Executar um modelo também exige memória para ativações, sobrecarga de execução e o cache KV, que cresce com o comprimento do prompt e da geração. Quantizar os pesos reduz a ocupação estática do modelo, mas contextos longos ainda exigem planejamento separado de memória.
Qual é a diferença entre GGUF e GPTQ ou AWQ?
GGUF é um formato de arquivo único que reúne pesos, configuração e tokenizador para runtimes locais como llama.cpp e Ollama e aceita checkpoints pré-quantizados de 1 a 8 bits. GPTQ e AWQ são métodos de quantização de 4 bits normalmente armazenados em checkpoints organizados em diretórios com um arquivo config.json. GPTQ calibra cada linha da matriz de pesos e AWQ preserva pesos críticos com base nas ativações.
Carregar um arquivo GGUF no Transformers economiza memória?
A maioria dos arquivos GGUF não economiza memória quando carregada pelo Hugging Face Transformers. Segundo a visão geral de quantização da Hugging Face, a maioria dos modelos GGUF é desquantizada para precisão completa durante o carregamento no Transformers e ocupa tanta memória quanto um modelo não quantizado, exceto por uma restrita exceção com kernel MPS em alguns modelos Qwen3.5. Aplicativos locais como llama.cpp e Ollama evitam esse comportamento do Transformers.
O que é NVFP4 em comparação com a quantização INT4?
NVFP4 é o formato de ponto flutuante de 4 bits da NVIDIA compatível com hardware Blackwell, enquanto INT4 representa pesos como inteiros de 4 bits. Ambos armazenam cada parâmetro em 0.5 bytes, reduzindo o armazenamento bruto dos pesos de forma semelhante à quantização inteira de 4 bits. Formatos de ponto flutuante como NVFP4 e MXFP8 de 8 bits também podem ser usados diretamente durante o treinamento e a implantação, como no Inkling 2 Mini da Thinking Machines Lab.
Fontes
- Hugging Face Transformers: visão geral da quantização
- Hugging Face Transformers: escolher um método de quantização
- Hugging Face Transformers: bitsandbytes
- Hugging Face Transformers: GPTQ
- Hugging Face Transformers: AWQ
- Thinking Machines Lab: anúncio do Inkling 2 Mini
- Cartão do modelo Hugging Face: thinkingmachines/Inkling-2-Mini



