Quantização de modelos no Ollama: guia completo sobre GGUF e perda de precisão

Você tem uma RTX 3060 com 12 GB de VRAM e quer executar o Llama 3 70B? O resultado é CUDA out of memory: nem um modelo 14B cabe. A quantização reduz um modelo 70B de 140 GB para 40 GB, mas qual é a perda de precisão?

As 500 mil avaliações da Red Hat trazem a resposta: a quantização de 8 bits recupera mais de 99% da precisão, enquanto a de 4 bits recupera 98,9%. No uso diário, a diferença é praticamente imperceptível; apenas benchmarks acadêmicos extremos conseguem medir pequenas variações.

Este artigo explica em detalhes os princípios da quantização GGUF, compara a precisão dos diferentes níveis e apresenta recomendações para GPUs de uso doméstico. Se a falta de VRAM limita os modelos que você pode executar ou se você tem dúvidas sobre a qualidade após a quantização, aqui estão as respostas de que precisa.

1. O que é quantização: a técnica que deixa modelos grandes mais leves

Talvez você já tenha passado por isto: uma foto em alta resolução ocupa mais de dez megabytes, mas, depois de enviada por um aplicativo de mensagens, cai para algumas centenas de kilobytes. Houve perda de qualidade? Sim. Ainda dá para enxergar tudo com clareza? Também.

A quantização de modelos segue mais ou menos a mesma lógica.

1.1 A essência da quantização

Os pesos de um modelo de linguagem costumam ser armazenados em FP16, ou seja, números de ponto flutuante de 16 bits. Um modelo com 7 bilhões de parâmetros precisa de cerca de 14 GB de memória em FP16, pois cada parâmetro ocupa 2 bytes.

O que a quantização faz é simples: converte esses valores de alta precisão para um formato de menor precisão. Em INT4, por exemplo, cada parâmetro ocupa apenas 0,5 byte. Assim, um modelo de 14 GB pode ser reduzido para cerca de 3,5 GB.

Uma analogia: FP16 é como registrar cada parâmetro com um decimal muito preciso, como 0,12345678. Depois da conversão para INT4, você guarda apenas um inteiro aproximado, como 3. Parte da precisão se perde, mas a informação continua ali.

1.2 Quanto espaço é economizado?

Reuni alguns dados de testes práticos do Will It Run AI. Veja o consumo de memória de um modelo 7B em diferentes níveis de quantização:

Percebeu? O Q4_K_M reduz o consumo de memória em 72%. Na prática, um modelo que antes exigia 14 GB de VRAM passa a funcionar em uma placa com 4 GB.

Quando consegui executar um modelo 7B pela primeira vez na minha RTX 3060, a sensação foi a de instalar um turbo em um carro velho. Antes eu estava limitado a modelos pequenos de 3B; de repente, podia usar um modelo intermediário de 7B.

1.3 Qual é o custo da quantização?

Toda compressão tem um preço, como fica evidente em fotografias. Uma imagem comprimida demais ganha desfoque e ruído. Com modelos, acontece algo parecido:

• Perda de precisão: valores de baixa precisão não conseguem representar exatamente os valores originais e introduzem erros.
• Perda de continuidade: INT4 usa inteiros discretos, enquanto FP16 usa decimais contínuos; algumas variações sutis podem desaparecer.

Mas a pergunta central é: qual é o tamanho dessa perda? Vale a pena?

É isso que vamos analisar a seguir com dados de 500 mil avaliações. Não precisa se preocupar antes da hora; vamos avançar passo a passo.

2. O formato GGUF: por que ele virou o padrão para modelos quantizados

Ao baixar um modelo quantizado, você provavelmente já percebeu que os arquivos terminam em .gguf. O que esse formato tem de especial?

2.1 O que é GGUF?

GGUF é a sigla de GPT-Generated Unified Format. O nome parece complicado, mas trata-se simplesmente de um formato de empacotamento de modelos criado especificamente para inferência.

Ele foi desenvolvido pela equipe do llama.cpp a partir de uma necessidade bastante prática: modelos já treinados precisam de um formato conveniente para serem executados. Foi assim que surgiu o GGUF.

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

O formato tem três vantagens principais:

Empacotamento em um único arquivo. Antes, para baixar um modelo do Hugging Face, era preciso obter vários arquivos: pesos, tokenizer, config.json e outros. O GGUF reúne tudo em um só arquivo. Basta baixar um .gguf, sem se preocupar com componentes ausentes.

Carregamento por mapeamento de memória (mmap). O nome soa sofisticado, mas o princípio é simples: o arquivo é mapeado diretamente para endereços de memória e o sistema lê cada parte quando necessário. Assim, não é preciso carregar o modelo inteiro na memória antes de começar. Isso é essencial para modelos grandes: carregar um 70B completo pode levar dezenas de segundos, enquanto o mmap pode permitir que a inferência comece em poucos segundos.

Compatibilidade entre plataformas. O mesmo arquivo GGUF funciona no Ollama, LM Studio, llama.cpp, KoboldCPP e outras ferramentas. Você pode trocar de aplicativo sem baixar o modelo novamente.

2.2 GGUF em comparação com outros formatos

Existem vários formatos de modelo, e é fácil confundi-los. Veja uma comparação simples:

Em resumo, o GGML foi o antecessor do GGUF e já foi descontinuado. Safetensors é usado para treinamento e ainda precisa ser convertido para inferência. O GGUF foi otimizado especificamente para inferência e é o formato padrão do Ollama.

Se você só quer executar um modelo para inferência, não precisa ficar em dúvida: GGUF é a escolha certa.

2.3 A relação entre Ollama e GGUF

Nos bastidores, o Ollama usa o llama.cpp para executar modelos. Como o llama.cpp trabalha com GGUF, todos os modelos do Ollama são, essencialmente, arquivos GGUF.

Ao executar ollama pull llama3, o Ollama baixa um arquivo GGUF do repositório de modelos. Os modelos da biblioteca oficial já vêm quantizados, e o padrão é Q4_K_M.

Mais adiante, veremos como baixar do Hugging Face modelos em outros níveis de quantização. Primeiro, é importante entender o formato para que as etapas práticas façam sentido.

3. Níveis de quantização: de Q2 a Q8, qual é o ideal para você?

Esta é a parte principal. Qual nível escolher? Q4_K_M ou Q5_K_M? O que significam os sufixos S, M e L? Vamos responder a cada pergunta.

3.1 Tabela comparativa dos níveis de quantização

Comece por esta tabela, baseada em testes do Will It Run AI com o modelo Llama 3 8B:

Os dois níveis em destaque são os que mais recomendo: Q5_K_M e Q4_K_M. Já explico por quê.

3.2 O que é K-quant? Como escolher entre os sufixos S, M e L?

Talvez você tenha notado a letra K nos níveis de quantização. Ela indica K-quant, uma estratégia de quantização com precisão mista.

O princípio pode parecer complexo, mas a ideia central é simples: nem todos os parâmetros são quantizados com a mesma precisão. Camadas mais sensíveis à precisão, como as de attention, usam uma precisão um pouco maior; camadas menos sensíveis, como as de FFN, são comprimidas com menor precisão.

Os sufixos S, M e L representam três graus de agressividade:

• S (Small): o mais agressivo, com maior compressão e maior perda de qualidade.
• M (Medium): equilibrado e recomendado.
• L (Large): conservador, com a melhor qualidade, mas arquivo maior.

Portanto, Q5_K_M e Q5_K_S pertencem ao nível Q5, mas o Q5_K_M oferece qualidade superior e ocupa mais espaço.

Como escolher? Minha recomendação é direta:

Use o sufixo M na maioria dos casos. O S pode ser agressivo demais e causar problemas; o L é conservador e consome memória desnecessária. O M fica no ponto de equilíbrio, com qualidade suficiente e consumo razoável.

3.3 A sensibilidade de cada tarefa à quantização

Há outro fator importante: para que você usa o modelo?

Cada tipo de tarefa reage de maneira diferente à perda de precisão. O Will It Run AI propôs esta ordem, da mais sensível para a menos sensível:

1. Programação: é a mais sensível. Código exige lógica rigorosa, e um único parâmetro incorreto pode impedir tudo de funcionar. Use Q5_K_M ou superior.
2. Raciocínio/matemática: muito sensível. Raciocínio lógico e cálculos matemáticos exigem alta precisão. Use Q5_K_M ou superior.
3. Escrita criativa: sensibilidade média. Há alguma margem para variação, então Q4_K_M é aceitável.
4. Conversa: é a menos sensível. Diálogos cotidianos têm menor exigência de precisão, e Q4_K_M funciona perfeitamente.
5. Resumo: também pouco sensível. Essa tarefa depende principalmente da compreensão, e Q4_K_M é suficiente.

Em poucas palavras: para programação e matemática, use alta precisão (Q5 ou superior); para conversas e resumos, uma precisão menor (Q4) também funciona bem.

Na minha experiência, modelos em Q4_K_M às vezes cometem erros estranhos ao gerar código, como escrever o nome de uma função incorretamente ou produzir uma lógica confusa. Ao mudar para Q5_K_M, esses problemas diminuíram bastante. Em conversas, porém, quase não percebo diferença entre Q4 e Q5.

4. A verdade sobre a perda de precisão: o que mostram mais de 500 mil avaliações

Agora vamos aos dados. Muitas pessoas temem que a quantização deixe o modelo menos inteligente, e eu também tinha essa preocupação. Depois de ler o relatório da Red Hat, ela praticamente desapareceu.

4.1 O que a Red Hat fez?

Em outubro de 2024, a Red Hat publicou o relatório “We ran over half a million evaluations on quantized LLMs”. A equipe realizou mais de 500 mil avaliações para comparar o desempenho de modelos quantizados com o de modelos originais.

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

"Realizamos mais de meio milhão de avaliações em LLMs quantizados para determinar o impacto da quantização na qualidade dos modelos em vários benchmarks e tarefas do mundo real."

Não se trata de uma conclusão baseada em alguns testes isolados, mas de uma avaliação sistemática em grande escala. Foram usados vários conjuntos de avaliação:

• Benchmarks acadêmicos: OpenLLM Leaderboard v1/v2, incluindo MMLU, HellaSwag, ARC e outros.
• Tarefas reais: Arena-Hard, que simula conversas reais com usuários; HumanEval, para geração de código; e HumanEval+, para testes de código.
• Similaridade textual: ROUGE, BERTScore e STS, para similaridade semântica.

Os testes abrangeram modelos de vários tamanhos: Llama 2 7B, 13B e 70B; Mixtral 8x7B MoE; modelos da família Qwen e outros.

4.2 Principal descoberta: taxa de recuperação da precisão

Os resultados são claros. Estes são os números obtidos com os métodos de quantização do llama.cpp:

A conclusão central é: a quantização de 8 bits é praticamente sem perdas, e a de 4 bits recupera, em média, 98,9% da precisão.

O que significa dizer que o “IC de 95% se sobrepõe ao BF16”? Em termos estatísticos, o desempenho do modelo quantizado em 8 bits não apresenta diferença significativa em relação ao modelo BF16 original. Ao repetir os testes muitas vezes, as distribuições dos resultados são quase iguais.

4.3 Modelos grandes e pequenos não são afetados da mesma forma

O relatório traz uma descoberta interessante: quanto maior o modelo, menor o impacto da quantização na precisão.

Em um modelo com 70 bilhões de parâmetros, o desempenho após a quantização de 4 bits fica quase no mesmo nível do original. Já em um modelo 7B, a quantização de 4 bits pode causar uma queda perceptível.

A razão é simples: modelos grandes têm mais parâmetros e maior redundância. Mesmo com alguma perda de precisão, ainda há parâmetros suficientes para compensá-la. Modelos pequenos já têm menos parâmetros e ficam mais vulneráveis após a compressão.

Na prática, isso significa:

• Q4 funciona bem em modelos grandes: um 70B Q4_K_M fica muito próximo da versão original.
• Em modelos pequenos, prefira Q5 ou superior: se houver VRAM suficiente, Q5_K_M ou Q6_K é uma opção mais segura para um modelo 7B.

4.4 Um equívoco comum: por que tanta gente diz que a quantização deixa o modelo pior?

Muitas pessoas afirmam que a qualidade cai bastante depois da quantização. O relatório da Red Hat analisou esse fenômeno e concluiu que o problema não está necessariamente na quantização, mas na forma de avaliar.

É comum testar o modelo em um único benchmark acadêmico, como MMLU, e concluir que ele ficou pior porque a pontuação caiu 5%. Um benchmark isolado, porém, não representa os cenários reais de uso.

A Red Hat usou vários conjuntos de avaliação, incluindo tarefas reais como Arena-Hard e HumanEval. Nessas tarefas, o desempenho dos modelos quantizados ficou muito próximo do original.

Em outras palavras, no uso cotidiano — conversas, programação e resumos — você quase não percebe a perda de qualidade causada pela quantização. A diferença só aparece em alguns benchmarks acadêmicos extremos.

Minha experiência prática é parecida: modelos em Q4_K_M são fluidos para conversas e resumos e só apresentam alguns problemas ocasionais ao gerar código. Não é que o modelo tenha ficado menos inteligente; são erros lógicos mais sutis. Ao mudar para Q5_K_M, a situação melhorou bastante.

5. Ollama na prática: como escolher e executar modelos quantizados

Depois da teoria, vamos à prática. Como escolher diferentes níveis de quantização no Ollama?

5.1 O comportamento padrão do Ollama

Quando você usa diretamente ollama pull ou ollama run para obter um modelo oficial, o nível de quantização padrão é Q4_K_M.

Por exemplo:

ollama pull llama3

Esse comando baixa a versão Q4_K_M do Llama 3 8B. O Ollama considera o Q4_K_M a opção com melhor custo-benefício: consumo de memória razoável e qualidade aceitável.

Mas e se você não estiver satisfeito com o Q4_K_M padrão e quiser outro nível?

5.2 Como baixar do Hugging Face um nível específico de quantização

O Ollama consegue baixar diretamente do Hugging Face modelos no formato GGUF. A sintaxe é:

ollama run hf.co/{用户名}/{仓库}:{量化级别}

Por exemplo, para baixar a versão Q8_0 do Llama 3.2 3B:

ollama run hf.co/bartowski/Llama-3.2-3B-Instruct-GGUF:Q8_0

Esse comando baixa do repositório de bartowski no Hugging Face a versão quantizada em Q8_0. bartowski é um publicador muito ativo de modelos quantizados e mantém repositórios com vários modelos e níveis de quantização.

Para encontrar modelos GGUF no Hugging Face, pesquise pelo termo GGUF. Uma busca por Llama-3 GGUF, por exemplo, retorna várias versões quantizadas.

Vultr - Servidor cloud NVMe de alto desempenho, 32 locais globais, deploy Docker com um clique

Ver preços →Anúncio

Alguns repositórios conhecidos de modelos quantizados:

• bartowski: atualizações rápidas e muitos modelos.
• MaziyarPanahi: muitos modelos grandes, com 70B ou mais.
• TheBloke: publicador tradicional de quantizações, embora alguns modelos não sejam mais atualizados.

5.3 Recomendações por configuração de hardware

A capacidade de VRAM é o principal fator para definir o nível de quantização. Esta tabela serve como referência para placas NVIDIA:

Alguns cuidados:

• O uso de VRAM varia: durante a inferência, não é apenas o modelo que ocupa memória; também há o KV cache e o buffer de contexto. Reserve de 10% a 20% para ter estabilidade.
• O tamanho do contexto afeta a memória: contextos longos exigem um KV cache maior. Se você usa contextos extensos com frequência, aumente a margem no orçamento de VRAM.
• Modelos MoE são diferentes: embora o Mixtral 8x7B tenha 47B parâmetros no total, ele usa apenas parte deles em cada inferência, e seu consumo de memória é menor do que o de um modelo denso com a mesma quantidade de parâmetros.

5.4 Princípio central: modelo menor com quantização mais precisa supera modelo maior com quantização agressiva

Este princípio é importante. Veja um exemplo:

Suponha que você tenha 8 GB de VRAM. Duas configurações cabem nessa memória:

• Modelo 7B Q5_K_M (~5,3 GB)
• Modelo 13B Q2_K (~5,0 GB)

Qual oferece o melhor desempenho?

A resposta é 7B Q5_K_M > 13B Q2_K.

O motivo é que a quantização Q2_K do modelo 13B é agressiva demais e causa uma perda evidente de precisão. Embora tenha mais parâmetros, a compressão já prejudicou muito a qualidade. O modelo 7B Q5_K_M tem menos parâmetros, mas preserva melhor a precisão e, por isso, apresenta um resultado geral superior.

Minha recomendação é: priorize o nível de quantização antes de considerar o tamanho do modelo. Se Q5 cabe na memória, não desça para Q3. Se um 7B Q5 cabe, não tente substituí-lo por um 13B Q2.

5.5 Teste prático com a minha RTX 3060

Minha placa é uma RTX 3060 com 12 GB. Estas são as configurações que uso com frequência:

• Conversas cotidianas: Llama 3.2 3B Q8_0, pois há memória suficiente e prefiro qualidade.
• Programação: Llama 3 8B Q5_K_M, priorizando qualidade.
• Testes com modelos grandes: Mixtral 8x7B Q4_K_M, cuja arquitetura MoE cabe por pouco nos 12 GB.

Na prática, essa combinação funciona muito bem. A fluidez do modelo 3B em Q8_0 para conversas é um pouco melhor do que a do 8B em Q4_K_M, talvez por causa da vantagem de usar um modelo pequeno com quantização mais precisa. Para programação, o Q5_K_M apresenta uma taxa de erros claramente menor do que o Q4.

Conclusão

Depois de todos esses detalhes, vale resumir os pontos principais.

A quantização existe para permitir que modelos grandes funcionem em hardware de uso doméstico. Um modelo 70B que originalmente exigiria 140 GB de VRAM pode ser reduzido para cerca de 40 GB. Essa é uma das tecnologias centrais para colocar modelos grandes ao alcance de usuários comuns.

Você pode ficar mais tranquilo quanto à perda de precisão. As 500 mil avaliações da Red Hat indicam que 8 bits são praticamente sem perdas, com mais de 99% de recuperação da precisão, e que a perda em 4 bits é controlável, com 98,9% de recuperação. Em cenários cotidianos, a diferença é quase imperceptível.

Os princípios centrais para escolher o nível de quantização são:

• Dentro do orçamento de VRAM, priorize a quantização mais precisa: se Q5 cabe, não desça para Q3.
• Ajuste de acordo com a sensibilidade da tarefa: use Q5 ou superior para programação; Q4 funciona para conversas.
• Modelos grandes toleram quantização mais agressiva: um 70B em Q4 é muito mais estável do que um 7B em Q4.

Minha sugestão é começar pelo Q5_K_M. Ele é um excelente ponto de equilíbrio: usa apenas 20% mais memória do que o Q4 e entrega uma qualidade claramente superior. Teste o efeito da quantização e depois ajuste de acordo com suas necessidades reais.

Se quiser se aprofundar, leia também os outros artigos desta série: Guia de introdução ao Ollama e Guia completo dos parâmetros do Modelfile. O Modelfile também permite personalizar níveis de quantização; com o que você aprendeu aqui, poderá configurar seus modelos com mais flexibilidade.

Quantização não é magia, mas uma técnica de equilíbrio: encontrar a melhor relação entre memória e qualidade. Ao dominá-la, sua placa de vídeo poderá executar modelos maiores e realizar muito mais tarefas.