¿Qué es la cuantización (Q4, Q8, GGUF) en los modelos de IA?

Si has buscado un modelo para ejecutar en local, te habrás encontrado con nombres como Q4_K_M, Q8_0 o IQ3_M y archivos que terminan en .gguf. No son caprichos: indican cuánto se ha comprimido el modelo, y de eso depende si cabe en tu gráfica, lo rápido que responde y lo bien que lo hace.

¿Qué significa cada cuantización, de un vistazo?

Los bits por parámetro son los que publica el repositorio de llama.cpp para un modelo real: no son números redondos porque cada bloque de pesos guarda además su escala, y las variantes _M combinan distintos niveles en distintas partes del modelo. La pérdida de calidad es orientativa y varía según el modelo y la tarea.

¿Por qué hace falta cuantizar?

Un modelo de lenguaje está formado por miles de millones de parámetros, y cada uno es un número que hay que guardar en memoria. La cuenta es sencilla:

Tamaño ≈ número de parámetros × bits por parámetro ÷ 8

Por ejemplo, con Llama 3.1 8B (unos 8.000 millones de parámetros), estos son los tamaños reales que publica llama.cpp:

A esto hay que sumar la memoria que necesita el contexto (la conversación y los documentos que le pasas), que crece cuanto más largo es.

Si quieres profundizar en la memoria de la gráfica, tienes nuestra guía de cuánta VRAM necesito.

¿Qué significa Q4, Q5 o Q8?

El número indica, de forma aproximada, cuántos bits se usan por parámetro. Menos bits significa un archivo más pequeño, pero también menos precisión.

En los modelos GGUF verás nombres como Q4_K_M o Q5_K_S:

• Q4, Q5, Q6, Q8: bits aproximados.
• K: los métodos “k-quant” de llama.cpp, que agrupan los pesos en superbloques con escalas propias y reparten mejor la precisión. Hoy son los más usados.
• S, M, L: variante pequeña, mediana o grande. La M es la más habitual como equilibrio.
• _0 y _1 (como Q4_0 o Q8_0): los métodos originales, más simples. Hugging Face los considera ya heredados, aunque Q8_0 sigue siendo muy común.
• IQ (por ejemplo IQ2_XXS, IQ3_S o IQ4_XS): métodos que usan una matriz de importancia (imatrix) para proteger los pesos que más influyen y así perder menos calidad en tamaños muy reducidos.

También empiezan a aparecer formatos como MXFP4, un formato de 4 bits en coma flotante por bloques que algunos modelos, como gpt-oss, usan de origen.

¿Cuánta calidad se pierde?

La forma habitual de medirlo es la perplejidad: cuánto “se sorprende” el modelo ante un texto de prueba. Cuanto menor, mejor. En las pruebas con las que llama.cpp presentó los k-quants en 2023, con LLaMA 7B:

• Q6_K quedó prácticamente igual que el original (+0,07 %).
• Q4_K_S subió la perplejidad en torno a un 2 %.
• Q2_K la subió casi un 15 %.

Las tendencias que se repiten:

• Q8 es prácticamente indistinguible del original en el uso diario.
• Q6 y Q5 pierden muy poco.
• Q4 (sobre todo las variantes K_M) es el punto dulce para la mayoría: se nota poco en conversación y tareas generales.
• Por debajo de Q4 la degradación se acelera: respuestas menos coherentes, más errores en razonamiento, código o idiomas distintos del inglés.
• Más parámetros suele compensar: en esas mismas pruebas, el modelo de 13B en Q2_K (5,13 GB) obtuvo mejor perplejidad que el de 7B sin cuantizar (13 GB).

Ojo con una idea muy extendida: que los modelos grandes “toleran mejor” la cuantización. En las pruebas de llama.cpp, el error relativo no bajó de forma constante al crecer el modelo; lo que ocurre es que un modelo grande parte de un nivel más alto y, aunque pierda algo, sigue por delante.

¿La cuantización hace el modelo más rápido?

Sí, al generar texto. Para escribir cada palabra el equipo tiene que leer el modelo entero de la memoria, así que un archivo más pequeño se lee antes. En las pruebas publicadas en el repositorio de llama.cpp con Llama 3.1 8B, la versión Q4_K_M generaba unos 72 tokens por segundo, frente a unos 51 de la Q8_0 y unos 29 de la versión de 16 bits, en el mismo equipo.

El salto más grande, de todos modos, se da cuando el modelo cabe entero en la VRAM. Si una parte se va a la RAM del sistema, la velocidad cae mucho, sea cual sea la cuantización.

¿Qué es exactamente GGUF?

GGUF es un formato de archivo binario creado por Georgi Gerganov, autor de llama.cpp, para guardar modelos listos para ejecutar. A diferencia de formatos que solo guardan los pesos, como safetensors, un archivo GGUF incluye en un único fichero los pesos (normalmente cuantizados) y un conjunto estándar de metadatos: arquitectura, tokenizador, plantilla de chat, etc.

Ventajas:

• Un solo archivo, fácil de descargar y mover.
• Carga rápida y funciona en CPU, GPU o repartido entre ambas, lo que permite ejecutar modelos aunque no quepan enteros en la gráfica (más lento, eso sí).
• Lo usan las herramientas más populares de IA local: llama.cpp, LM Studio, GPT4All y Ollama.

En Hugging Face es habitual encontrar el mismo modelo en muchas versiones GGUF, una por cada cuantización; la propia web incluye un visor que muestra los metadatos y la precisión de cada tensor. Ollama puede descargar directamente esas versiones con ollama run hf.co/usuario/repositorio:Q4_K_M, y si no indicas cuantización elige Q4_K_M cuando está disponible. Si dudas entre herramientas, mira nuestra comparativa Ollama vs LM Studio.

¿Hay otros formatos además de GGUF?

Sí. Algunos de los que verás:

Para empezar en casa, GGUF es la opción más sencilla y compatible.

¿Cómo elijo la cuantización adecuada?

1. Mira cuánta memoria tienes: VRAM de la gráfica o memoria unificada si usas un Mac.
2. Elige el modelo más grande que quepa en Q4_K_M dejando margen para el contexto. Como referencia, Gemma 3 en Q4_K_M ocupa 3,3 GB en 4B, 8,1 GB en 12B y 17 GB en 27B.
3. Si te sobra espacio, sube a Q5_K_M o Q6_K antes que pasar a un modelo enorme que no quepa entero.
4. Si no te cabe, baja de tamaño de modelo antes que bajar a Q2 o Q3. Si tienes que bajar de 4 bits, prefiere las variantes IQ hechas con matriz de importancia.
5. Evita que el modelo se reparta entre GPU y RAM si buscas velocidad: funciona, pero mucho más lento.

Si estás valorando ampliar el equipo, tienes nuestra guía de qué gráfica comprar para IA local.

¿Cuál elegimos? Nuestra recomendación

Para la mayoría de usuarios, Q4_K_M es la cuantización por defecto: ocupa poco, mantiene buena calidad y permite usar modelos más grandes en gráficas domésticas. Si tu equipo va sobrado, Q5_K_M o Q6_K son una mejora sencilla, y Q8_0 es para cuando quieres la máxima fidelidad y te sobra memoria. Por debajo de Q4, úsalo solo si es la única forma de ejecutar un modelo concreto y prueba siempre si el resultado te convence.

Según los usuarios que comparan cuantizaciones en Hacker News, con modelos recientes de unos 27B la diferencia entre BF16 y Q8_0 es prácticamente nula (del orden de un 0,1–0,3 % de perplejidad) y la de Q4_K_M ronda el 1–3 %, difícil de notar en el uso normal. No todos coinciden: otros avisan de que en modelos como Llama 3.3 ya se aprecia algo de degradación al pasar de Q5 a Q4, así que si te cabe, Q5_K_M es una apuesta más segura.