Quantization Aware Training: guía para mejorar la inferencia local de Gemma 4

¿Qué es la cuantización?

La cuantización es una técnica de compresión que reduce la precisión de los pesos del modelo. 

Los modelos de lenguaje grandes suelen almacenarse en formatos de alta precisión como BF16 o FP16, que preservan la calidad pero requieren mucha memoria. La cuantización convierte esos pesos a formatos de menos bits, como 8 o 4 bits, para que el modelo use menos VRAM y se ejecute con más facilidad en local. Hugging Face señala que la cuantización a 8 bits puede reducir el uso de memoria aproximadamente a la mitad, mientras que a 4 bits lo reduce aún más.

El compromiso es que una menor precisión puede reducir la calidad de salida, especialmente si el modelo no está optimizado para cuantización. En pocas palabras: BF16 y FP16 suelen ofrecer la mejor calidad pero consumen más memoria; los modelos de 8 bits son más pequeños y normalmente mantienen una calidad alta, y los de 4 bits son mucho más pequeños pero pueden perder algo de precisión o estabilidad. 

Para inferencia local, este intercambio suele compensar, porque permite ejecutar modelos más grandes en GPUs de consumo sin depender de hardware caro de centro de datos.

¿Qué es Quantization Aware Training?

Quantization-Aware Training (QAT) es una técnica de entrenamiento en la que el modelo se entrena o afina simulando el comportamiento de baja precisión. Esto ayuda a que el modelo se mantenga más estable tras la cuantización y puede mejorar el rendimiento de la inferencia local con anchos de bit bajos.

¿Qué hace diferente a QAT?

El enfoque habitual, la cuantización posterior al entrenamiento, comprime un modelo una vez entrenado. Es simple y práctico, pero el modelo puede perder algo de calidad porque no fue entrenado para manejar pesos de baja precisión. 

Según la documentación de Google AI Edge, la cuantización posterior al entrenamiento es un paso de conversión que puede reducir el tamaño del modelo y mejorar la latencia, normalmente con poca pérdida de precisión. No obstante, la calidad final puede depender del modelo y del nivel de cuantización. 

Quantization-Aware Training, o QAT, adopta un enfoque distinto. En lugar de cuantizar solo después del entrenamiento, QAT simula el comportamiento de baja precisión durante el entrenamiento o el fine-tuning. Así, el modelo aprende a mantenerse estable cuando se convierte después a un formato más pequeño. Minimiza la pérdida de calidad al comprimir el modelo.

Por eso Gemma 4 QAT es útil para IA local. Está concebido pensando en la cuantización, de modo que conserva más calidad del modelo original usando menos memoria. Para quienes ejecutan modelos en GPUs de consumo, esto puede traducirse en mayor estabilidad a bajos bits, menor uso de VRAM y una inferencia local más práctica.

Paso 1: instala dependencias y compila llama.cpp

Antes de descargar los modelos, primero preparamos el entorno local. Este tutorial se probó en una máquina con una GPU NVIDIA RTX 4090 y 24 GB de VRAM. Usaremos llama.cpp como runtime de inferencia, GGUF como formato del modelo y los archivos cuantizados UD-Q4_K_XL.

Configuración probada:

• GPU: NVIDIA RTX 4090
• VRAM: 24 GB
• Runtime: llama.cpp
• Formato de modelo: GGUF
• Cuantización: UD-Q4_K_XL

Compararemos estos dos modelos GGUF de Unsloth:

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

Primero, comprueba que tu GPU esté disponible.

nvidia-smi

A continuación, instala los paquetes del sistema necesarios para compilar llama.cpp.

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

Clona el repositorio oficial de llama.cpp.

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

Ahora compila llama.cpp con soporte CUDA habilitado. Así las capas del modelo se ejecutarán en la GPU y no solo en la CPU.

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

Compila los binarios necesarios.

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

Tras la compilación, el binario principal que usaremos es llama-server. Nos permite ejecutar el modelo GGUF en local y expone un endpoint de API compatible con OpenAI que podemos consultar con curl. 

Paso 2: descarga los modelos Gemma 4 12B sin QAT y con QAT 

Con llama.cpp listo, podemos descargar desde Hugging Face ambas variantes del modelo Gemma 4 12B. Bajaremos el modelo instruccional estándar y la versión QAT en formato GGUF.

Primero, instala la CLI de Hugging Face Hub con soporte de descarga más rápida.

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

Activa las descargas Xet de alto rendimiento.

export HF_XET_HIGH_PERFORMANCE=1

Descarga el modelo instruccional estándar Gemma 4 12B en 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*"

Ahora, descarga la versión QAT con el mismo formato de cuantización.

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*"

Las banderas --include aseguran que solo descarguemos los archivos necesarios para este tutorial, en lugar de clonar todo el repositorio. Aquí estamos bajando los archivos GGUF UD-Q4_K_XL y los archivos mmproj-BF16 que usa el paquete del modelo. 

Cuando termine la descarga, confirma que existen ambas carpetas de modelo.

ls models

Salida esperada:

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

A estas alturas, tanto el modelo sin QAT como el QAT están disponibles en local y podemos empezar a servirlos con llama-server.

Paso 3: ejecuta el modelo sin QAT con llama-server

Empezaremos ejecutando el modelo instruccional Gemma 4 12B estándar. Esto nos da una línea base para compararla después con la versión QAT usando los mismos ajustes.

Inicia el modelo sin QAT con 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

Esto inicia un servidor local compatible con OpenAI en http://localhost:8001.

Abre otra terminal y envía una solicitud al 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
}'

En este comando usamos el endpoint local /v1/chat/completions, que sigue el formato de API compatible con OpenAI. El prompt pide al modelo que explique el Quantization-Aware Training, y max_tokens está fijado en 512 para garantizar que ambas variantes del modelo se prueben con la misma longitud de salida. 

En nuestra prueba con la RTX 4090, el modelo sin QAT arrojó los siguientes tiempos:

• Tokens del prompt: 40
• Tokens generados: 512
• Velocidad de prompt: 510.22 tokens/seg
• Velocidad de generación: 94.65 tokens/seg
• Tiempo total: 5.516 seg

Uso de memoria de la GPU:

9247 MiB / 24564 MiB

Esto nos da el rendimiento base del modelo Gemma 4 12B estándar. En el siguiente paso, ejecutaremos la versión QAT con la misma configuración y compararemos los resultados.

Paso 4: ejecuta y prueba el modelo QAT

Ahora ejecutaremos la versión QAT de Gemma 4 12B usando los mismos ajustes de llama-server. Asegúrate de detener el servidor anterior (sin QAT) antes de iniciar este, porque ambos comandos usan el mismo puerto.

Inicia el 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

Esto inicia el modelo QAT en el mismo endpoint local compatible con OpenAI, http://localhost:8001.

Ahora envía el mismo prompt de prueba al 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
}'

En nuestra prueba con la RTX 4090, el modelo QAT arrojó los siguientes tiempos:

1. Tokens del prompt: 40
2. Tokens generados: 512
3. Velocidad de prompt: 593.93 tokens/seg
4. Velocidad de generación: 101.65 tokens/seg
5. Tiempo total: 5.114 seg

Uso de memoria de la GPU:

8627 MiB / 24564 MiB

También puedes copiar la URL del servidor local (http://localhost:8001) y pegarla en tu navegador:

Esto abre la interfaz web integrada de llama.cpp, que te ofrece una interfaz tipo ChatGPT para probar el modelo local. Puedes usarla para chatear con el modelo QAT directamente en el navegador, experimentar con prompts y utilizarlo como asistente local en tu día a día. 

Comparativa: QAT vs. sin QAT

Tras probar ambos modelos con el mismo prompt y la misma configuración del servidor, podemos comparar directamente su rendimiento en la RTX 4090.

En esta ejecución, el modelo QAT fue a la vez más rápido y ligero que el modelo sin QAT. Usó 620 MiB menos de VRAM, reduciendo el consumo de memoria alrededor de un 6,7%. Para inferencia local esto es útil porque cada mega ahorrado ayuda al ejecutar modelos grandes en GPUs de consumo.

El modelo QAT también generó tokens más rápido, pasando de 94.65 tokens/seg a 101.65 tokens/seg. Es aproximadamente un 7,4% más de velocidad de generación, reduciendo el tiempo total de 5,516 a 5,114 segundos.

En el uso diario, el modelo QAT se sintió más fluido y ágil. La calidad de las respuestas también pareció más estable en esta prueba, que es la razón principal por la que QAT es útil: ayuda al modelo a manejar la cuantización de pocos bits con menos pérdida de calidad, manteniendo los beneficios de memoria y velocidad de un modelo comprimido.

Reflexiones finales

Google está haciendo un trabajo fantástico para la comunidad de IA local. Con modelos como Gemma 4 y técnicas como QAT, el sueño de ejecutar modelos potentes en local, completamente offline e incluso en hardware de consumo se está haciendo realidad. 

Lo más interesante es que no se trata solo de reducir el tamaño del modelo. Con QAT, no estamos simplemente sacrificando calidad para que el modelo quepa: obtenemos modelos diseñados para funcionar mejor en formatos de pocos bits, mejorando la experiencia de IA local. En esta prueba, el modelo QAT fue más rápido, ligero y agradable de usar que la versión sin QAT.

Ahora tengo muchas ganas de probar la versión MTP del modelo, que podría aumentar aún más la velocidad, quizá hasta 2x. Eso facilitaría mucho trasladar más parte de mi flujo de trabajo a la IA local. Podría ejecutar el modelo en local, conectarlo con herramientas como OpenCode y empezar a editar archivos de proyecto directamente con un asistente privado en mi máquina.

Esta nueva ola de IA local está cambiando cómo pensamos el uso de sistemas de IA. Tareas que antes requerían grandes despliegues en la nube, especialmente flujos multimodales con texto, imagen y vídeo, poco a poco están siendo posibles en máquinas locales. Para desarrolladores, investigadores y creadores que valoran la privacidad, la velocidad y el control, es una dirección muy prometedora.