Quantization Aware Training: um guia para melhorar a inferência local do Gemma 4

O que é quantização?

Quantização é uma técnica de compressão que reduz a precisão dos pesos do modelo. 

Grandes modelos de linguagem geralmente são armazenados em formatos de alta precisão como BF16 ou FP16, que preservam a qualidade, mas exigem bastante memória. A quantização converte esses pesos para formatos de menos bits, como 8 ou 4 bits, fazendo com que o modelo use menos VRAM e rode com mais facilidade localmente. A Hugging Face observa que a quantização em 8 bits pode praticamente cortar o uso de memória pela metade, enquanto a de 4 bits reduz ainda mais.

O trade-off é que a menor precisão às vezes pode reduzir a qualidade da saída, especialmente se o modelo não foi otimizado para quantização. Em termos simples, BF16 e FP16 costumam oferecer a melhor qualidade, mas usam mais memória; modelos em 8 bits são menores e normalmente mantêm boa qualidade, e os de 4 bits são bem menores, porém podem perder um pouco em acurácia ou estabilidade. 

Para inferência local, esse trade-off geralmente compensa, pois permite rodar modelos maiores em GPUs de consumo, sem depender de hardware caro de data center.

O que é Quantization Aware Training?

Quantization-Aware Training (QAT) é uma técnica em que o modelo é treinado ou ajustado simulando o comportamento de baixa precisão. Isso ajuda o modelo a ficar mais estável após a quantização e pode melhorar a performance da inferência local em larguras de bits baixas.

O que torna o QAT diferente?

A abordagem comum, a quantização pós-treinamento, comprime o modelo depois de já ter sido treinado. É simples e prática, mas o modelo pode perder qualidade porque não foi treinado para lidar com pesos de baixa precisão. 

Segundo a documentação do Google AI Edge, a quantização pós-treinamento é uma etapa de conversão que pode reduzir o tamanho do modelo e melhorar a latência, geralmente com pouca perda de acurácia. Porém, a qualidade final ainda pode depender do modelo e do nível de quantização. 

Quantization-Aware Training, ou QAT, adota outra abordagem. Em vez de quantizar só depois do treinamento, o QAT simula o comportamento de baixa precisão durante o treinamento ou o fine-tuning. Isso ajuda o modelo a aprender a se manter estável quando for convertido para um formato menor. Ele minimiza a perda de qualidade quando o modelo é comprimido.

É por isso que o Gemma 4 QAT é útil para IA local. Ele é construído já pensando em quantização, então consegue manter mais da qualidade do modelo original usando menos memória. Para quem roda modelos em GPUs de consumo, isso pode significar mais estabilidade em poucos bits, menor uso de VRAM e uma inferência local mais prática.

Etapa 1: instale as dependências e faça o build do llama.cpp

Antes de baixar os modelos, precisamos preparar o ambiente local. Este tutorial foi testado em uma máquina com GPU NVIDIA RTX 4090 e 24 GB de VRAM. Vamos usar o llama.cpp como runtime de inferência, GGUF como formato de modelo e os arquivos quantizados UD-Q4_K_XL.

Configuração testada:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Formato do modelo: GGUF
• Quantização: UD-Q4_K_XL

Vamos comparar os dois modelos Unsloth em GGUF a seguir:

• unsloth/gemma-4-12B-it-GGUF
• unsloth/gemma-4-12B-it-qat-GGUF

Primeiro, verifique se sua GPU está disponível.

nvidia-smi

Em seguida, instale os pacotes de sistema necessários para compilar o llama.cpp.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y

Clone o repositório oficial do llama.cpp.

git clone https://github.com/ggml-org/llama.cpp

Agora faça o build do llama.cpp com suporte a CUDA habilitado. Isso permite que as camadas do modelo rodem na GPU em vez de apenas na CPU.

cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF \
    -DGGML_CUDA=ON

Compile os binários necessários.

cmake --build llama.cpp/build \
    --config Release \
    -j \
    --clean-first \
    --target llama-cli llama-mtmd-cli llama-server llama-gguf-split

Depois do build, o binário principal que vamos usar é o llama-server. Ele permite rodar o modelo GGUF localmente e expõe um endpoint de API compatível com OpenAI que podemos consultar com curl. 

Etapa 2: baixe os modelos Gemma 4 12B sem QAT e com QAT 

Com o llama.cpp pronto, podemos baixar as duas variantes do Gemma 4 12B na Hugging Face. Vamos baixar o modelo instruído regular e a versão QAT em formato GGUF.

Primeiro, instale o CLI do Hugging Face Hub com suporte a downloads mais rápidos.

pip install -U "huggingface_hub[hf_xet]" hf-xet hf_transfer

Ative os downloads de alta performance do Xet.

export HF_XET_HIGH_PERFORMANCE=1

Baixe o modelo instruído Gemma 4 12B em formato GGUF.

hf download unsloth/gemma-4-12B-it-GGUF \
  --local-dir models/gemma-4-12B-it-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

Agora baixe a versão QAT usando o mesmo formato de quantização.

hf download unsloth/gemma-4-12B-it-qat-GGUF \
  --local-dir models/gemma-4-12B-it-qat-GGUF \
  --include "*mmproj-BF16*" \
  --include "*UD-Q4_K_XL*"

As flags --include garantem que baixemos apenas os arquivos necessários para este tutorial, em vez de clonar o repositório completo. Aqui, estamos baixando os arquivos GGUF UD-Q4_K_XL e os arquivos mmproj-BF16 usados pelo pacote do modelo. 

Após os downloads, confirme que as duas pastas dos modelos existem.

ls models

Saída esperada:

gemma-4-12B-it-GGUF
gemma-4-12B-it-qat-GGUF

Neste ponto, os modelos sem QAT e com QAT estão disponíveis localmente e já podemos servi-los com o llama-server.

Etapa 3: rode o modelo sem QAT com o llama-server

Vamos começar rodando o modelo instruído Gemma 4 12B regular. Isso nos dá uma linha de base para depois comparar com a versão QAT usando as mesmas configurações.

Inicie o modelo sem QAT com o llama-server.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Isso inicia um servidor local compatível com OpenAI em http://localhost:8001.

Abra outro terminal e envie uma requisição para o servidor local.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

Neste comando, usamos o endpoint local /v1/chat/completions, que segue o formato de API compatível com OpenAI. O prompt pede para o modelo explicar o quantization-aware training, e max_tokens está definido como 512 para garantir que as duas variantes sejam testadas com o mesmo comprimento de saída. 

No nosso teste com a RTX 4090, o modelo sem QAT apresentou os seguintes tempos:

• Tokens de prompt: 40
• Tokens de resposta: 512
• Velocidade do prompt: 510,22 tokens/s
• Velocidade de geração: 94,65 tokens/s
• Tempo total: 5,516 s

O uso de memória da GPU foi:

9247 MiB / 24564 MiB

Isso nos dá a linha de base de performance do Gemma 4 12B regular. Na próxima etapa, vamos rodar a versão QAT com a mesma configuração e comparar os resultados.

Etapa 4: rode e teste o modelo QAT

Agora vamos rodar a versão QAT do Gemma 4 12B usando as mesmas configurações do llama-server. Lembre-se de parar o servidor anterior (sem QAT) antes de iniciar este, pois ambos usam a mesma porta.

Inicie o modelo QAT.

./llama.cpp/llama-server \
  -m models/gemma-4-12B-it-qat-GGUF/*UD-Q4_K_XL*.gguf \
  --host 0.0.0.0 \
  --port 8001 \
  --ctx-size 8192 \
  --n-gpu-layers 99 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Isso inicia o modelo QAT no mesmo endpoint local compatível com OpenAI, http://localhost:8001.

Agora envie o mesmo prompt de teste para o modelo QAT.

time curl http://localhost:8001/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
  "model": "gemma-4-12B-it-qat",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful local AI assistant."
    },
    {
      "role": "user",
      "content": "Explain why quantization-aware training is useful for running LLMs on consumer GPUs."
    }
  ],
  "temperature": 1.0,
  "top_p": 0.95,
  "max_tokens": 512
}'

No nosso teste com a RTX 4090, o modelo QAT apresentou os seguintes tempos:

1. Tokens de prompt: 40
2. Tokens de resposta: 512
3. Velocidade do prompt: 593,93 tokens/s
4. Velocidade de geração: 101,65 tokens/s
5. Tempo total: 5,114 s

O uso de memória da GPU foi:

8627 MiB / 24564 MiB

Você também pode copiar a URL do servidor local (http://localhost:8001) e colar no navegador:

Isso abre a interface web nativa do llama.cpp, que oferece uma experiência semelhante ao ChatGPT para testar o modelo local. Você pode usá-la para conversar com o modelo QAT direto no navegador, experimentar prompts e usar o modelo como um assistente local no dia a dia. 

Compare os resultados: QAT vs. sem QAT

Depois de testar ambos os modelos com o mesmo prompt e configurações de servidor, podemos comparar diretamente o desempenho na RTX 4090.

Neste teste, o modelo QAT foi mais rápido e mais leve que o modelo sem QAT. Ele usou 620 MiB a menos de VRAM, reduzindo o uso de memória em cerca de 6,7%. Isso é valioso para inferência local, porque cada MiB economizado ajuda ao rodar modelos grandes em GPUs de consumo.

O modelo QAT também gerou tokens mais rápido, subindo de 94,65 tokens/s para 101,65 tokens/s. Isso representa cerca de 7,4% de ganho em velocidade de geração, reduzindo o tempo de execução de 5,516 segundos para 5,114 segundos.

No dia a dia, o modelo QAT pareceu mais fluido e responsivo. A qualidade das respostas também se mostrou mais estável neste teste — que é o principal motivo para usar QAT: ele ajuda o modelo a lidar com quantização de poucos bits com menos perda de qualidade, mantendo as vantagens de memória e velocidade de um modelo comprimido.

Considerações finais

O Google vem fazendo um trabalho incrível para a comunidade de IA local. Com modelos como o Gemma 4 e técnicas como QAT, o sonho de rodar modelos de IA poderosos localmente, totalmente offline e até em hardware de consumo está virando realidade. 

O mais empolgante é que não se trata apenas de reduzir o tamanho do modelo. Com QAT, não estamos simplesmente abrindo mão de qualidade para o modelo caber. Estamos obtendo modelos pensados para rodar melhor em formatos de poucos bits, elevando a experiência de IA local. Neste teste, o modelo QAT foi mais rápido, mais leve e mais suave de usar do que a versão sem QAT.

Agora estou animado para testar a versão MTP do modelo, que pode aumentar ainda mais a velocidade, possivelmente em 2x. Isso facilitaria muito migrar mais partes do meu fluxo de trabalho para IA local. Eu poderia rodar o modelo localmente, conectá-lo a ferramentas como o OpenCode e começar a editar arquivos de projeto diretamente com um assistente privado e local.

Essa nova onda de IA local está mudando como pensamos o uso de sistemas de IA. Tarefas que antes exigiam grandes estruturas em nuvem, especialmente fluxos multimodais com texto, imagem e vídeo, estão aos poucos se tornando possíveis em máquinas locais. Para desenvolvedores, pesquisadores e makers que valorizam privacidade, velocidade e controle, esse é um caminho muito promissor.