Inicio›Guías›Qué es GGUF y qué cuantización bajar: Q4_K_M, Q5_K_M o Q8_0, medidos en tamaño, velocidad y calidad

Elegir · Guía

Qué es GGUF y qué cuantización bajar: Q4_K_M, Q5_K_M o Q8_0, medidos en tamaño, velocidad y calidad

GGUF es el formato de modelo en un solo archivo que leen llama.cpp, Ollama y LM Studio. El Q4_K_M, Q5_K_M o Q8_0 del nombre es la cuantización: cuántos bits conserva cada peso. Q4_K_M es lo habitual: en nuestra prueba pesó el 59 % de Q8_0 y eligió el mismo token siguiente que el original el 89 % de las veces.

Medido y escrito por Local AI ScopePublicado el Cifras medidas por Local AI Scope

GGUF es el formato de modelo en un solo archivo que leen llama.cpp, Ollama y LM Studio. El Q4_K_M, Q5_K_M o Q8_0 del nombre es la cuantización: cuántos bits conserva cada peso. Q4_K_M es lo habitual: en nuestra prueba pesó el 59 % de Q8_0 y eligió el mismo token siguiente que el original el 89 % de las veces.

El 18 de noviembre de 2026 bajamos los GGUF oficiales de Qwen2.5 1.5B Instruct en 6 versiones (de F16 a Q3_K_M) y los pasamos por llama.cpp (build b12500) en un servidor Linux sin tarjeta gráfica, con un procesador AMD Ryzen 7 7730U y 8 hilos. Medimos cuánto pesa cada archivo, a qué velocidad escribe y cuántas veces su elección del token siguiente difiere de la del modelo sin cuantizar. Después pasamos los 28 modelos de nuestro buscador de modelos por el mismo cálculo que usa la herramienta, para ver qué cabe en 8, 12, 16, 24 y 32 GB con cada nivel. Todo lo que sigue va etiquetado con su origen.

Qué es GGUF y qué significa Q4_K_M en el nombre del archivo

Un archivo GGUF lleva dentro todo lo que un modelo necesita para funcionar, de una pieza: los pesos, el tokenizador, la arquitectura y, normalmente, la plantilla de chat. Por eso puedes bajar un solo archivo y abrirlo tal cual en llama.cpp, LM Studio u Ollama. El formato nació en el proyecto llama.cpp, y esos 3 programas lo leen porque se apoyan en llama.cpp y en su biblioteca ggml.

llama.cppllama.cppFicha del programa

La cuantización es la compresión. Un modelo sin cuantizar guarda cada peso en 16 o 32 bits; un archivo cuantizado lo guarda en menos, por bloques que comparten una escala. El nombre te dice cómo:

  • El número (Q3, Q4, Q5, Q6, Q8) son los bits de base por peso.
  • La K marca la familia «k-quants», que trabaja por bloques agrupados en superbloques. Q8_0 y Q4_0 son la familia antigua, más sencilla.
  • La _S, _M o _L es la mezcla: pequeña, mediana o grande. No es el tamaño del modelo, sino cuántos tensores se quedan con más precisión.

Esto último lo comprobamos abriendo los archivos. Nuestro Q4_K_M tiene 169 tensores a 4 bits (q4_K) y 29 a 6 bits (q6_K); Q5_K_M tiene el mismo reparto 169/29 con 5 bits de base; Q6_K y Q8_0 usan un único tipo para los 198 tensores cuantizados. O sea, cuando eliges Q4_K_M no eliges «todo a 4 bits»: eliges 4 bits con las partes más delicadas protegidas. Por eso llama.cpp informa de 5,00 bits por peso en este Q4_K_M y no de 4.

Repositorio GGUF oficial de Qwen2.5 1.5B Instruct en Hugging Face con un archivo por cuantización, de q2_k a fp16
El repositorio oficial: un archivo GGUF por nivel, de 753 MB en Q2_K a 3,56 GB en FP16 Captura: Hugging Face, repositorio oficial de Qwen, 18-11-2026

Si lo que dudas es entre GGUF y los safetensors originales, que son los que cargan vLLM y transformers, esa comparación está en nuestra guía vLLM vs Ollama, y en un Mac, en MLX vs GGUF.

Niveles de cuantización GGUF: cuánto pesa cada uno

La regla general se cumple: menos bits, archivo más pequeño. Pero no baja en línea recta, por los tensores protegidos y por las partes que nunca se comprimen. Estos son los 6 archivos que medimos, todos del repositorio oficial de Qwen:

Nivel Archivo
(MB)
Bits
por
peso
vs
Q8_0
F16 3.560 16,00 188 %
Q8_0 1.895 8,50 100 %
Q6_K 1.464 6,56 77 %
Q5_K_M 1.285 5,76 68 %
Q4_K_M 1.117 5,00 59 %
Q3_K_M 924 4,13 49 %

Este modelo es pequeño y solo su vocabulario tiene 151.936 tokens: eso explica, probablemente, que sus niveles queden tan juntos. En modelos más grandes la escalera se abre: entre los modelos de nuestro catálogo que publican los dos archivos, Q4_K_M pesa de media el 62 % de Q8_0, Q5_K_M el 72 % y Q6_K el 82 %. En Qwen3 8B son 8,11 GiB en Q8_0, 6,26 en Q6_K, 5,45 en Q5_K_M, 4,68 en Q4_K_M y 3,84 en Q3_K_M.

Terminal con los 6 archivos GGUF de Qwen2.5 1.5B, su tamaño en bytes y los bits por peso que informa llama.cpp
Los 6 archivos en nuestro disco: Q4_K_M pesa 1.117.320.736 bytes y llama.cpp lo lee como 5,00 bits por peso Captura: nuestra terminal, llama.cpp b12500, 18-11-2026

Q4_K_M vs Q5_K_M vs Q8_0: cuánta calidad pierdes

¿Cómo se mide lo que pierde un archivo comprimido? Con el método que trae llama.cpp. Primero, el modelo F16 leyó 10.240 tokens de texto de la Wikipedia en inglés (el conjunto de prueba wikitext-2, 20 bloques de 512 tokens) y guardamos, en cada posición, qué probabilidad daba a cada posible token siguiente. Después cada archivo cuantizado leyó exactamente el mismo texto y llama-perplexity los comparó. Importan dos cifras: cuántas veces el token favorito del modelo cuantizado coincide con el del original, y cuánto sube su perplejidad (PPL) (cuánto le sorprende el texto real; cuanto más baja, mejor).

Nivel Misma
primera
opción
(%)
PPL
vs F16
(%)
KLD
medio
Q8_0 97,7 +0,3 0,0015
Q6_K 93,6 +1,2 0,011
Q5_K_M 91,8 +1,2 0,017
Q4_K_M 89,0 +5,6 0,042
Q3_K_M 82,2 +13,4 0,117
Terminal con los resultados de llama-perplexity por cuantización: perplejidad, KLD medio y porcentaje de misma primera opción
Nuestra medida de calidad: del 97,7 % de primeras opciones idénticas en Q8_0 al 82,2 % en Q3_K_M Captura: nuestra terminal, llama.cpp b12500, 18-11-2026

Q8_0 es prácticamente indistinguible del original: la misma primera opción en el 97,7 % de los tokens y un 0,3 % más de perplejidad. Q6_K y Q5_K_M cuestan lo mismo en perplejidad (+1,2 %), aunque Q5_K_M se desvía algo más a menudo en su primera opción. Q4_K_M es el primer escalón de verdad: +5,6 % de perplejidad y una primera opción distinta en más o menos 1 de cada 9 tokens. Eso no quiere decir 1 palabra equivocada de cada 9: una primera opción distinta no es por fuerza una opción equivocada. Q3_K_M es donde empieza a doler: más del doble de pérdida de perplejidad que Q4_K_M y casi 3 veces su desviación (la columna KLD).

Un límite, dicho claro: es 1 modelo de 1.500 millones de parámetros medido sobre 1 texto en inglés. No hemos medido modelos más grandes de esta forma, así que no les ponemos cifra.

Velocidad: el archivo pequeño también escribe más rápido

En un ordenador sin tarjeta gráfica, escribir cada token obliga a leer el modelo entero de la memoria, así que menos archivo es más tokens por segundo. Nuestra prueba con llama-bench (128 tokens escritos y un prompt de 512 leído, 3 repeticiones, 8 hilos) lo confirma. Por una vez, ponerse a dieta te hace más rápido:

CPU
18-11-2026
Escribe
(tok/s)
Lee
(tok/s)
F16 11,9 61
Q8_0 21,8 106
Q6_K 28,4 171
Q5_K_M 30,2 154
Q4_K_M 34,2 143
Q3_K_M 39,3 163

La velocidad de escritura sube en orden según baja el archivo: Q4_K_M escribe un 57 % más rápido que Q8_0 en el mismo procesador. La lectura del prompt no sigue ese orden: ahí el trabajo es sobre todo de cálculo y no de memoria, así que depende de cómo se desempaqueta cada formato en esta CPU. Un matiz: el servidor tenía otros trabajos en marcha a la vez, así que diferencias pequeñas como la de Q6_K frente a Q5_K_M quedan dentro del ruido. En tarjeta gráfica no lo hemos medido.

Terminal con los resultados de llama-bench en CPU para Qwen2.5 1.5B de F16 a Q3_K_M, pp512 y tg128 en tokens por segundo
llama-bench en nuestra CPU: la escritura pasa de 11,89 tok/s en F16 a 39,31 en Q3_K_M Captura: nuestra terminal, llama.cpp b12500, 18-11-2026

Qué cabe en 8, 12, 16, 24 y 32 GB con cada cuantización

Aquí es donde la cuantización se gana el sueldo. Contamos, con el mismo cálculo que usa nuestro buscador de modelos (pesos + la caché KV real del modelo + un margen para el programa, con 8.192 tokens de contexto), cuántos de nuestros 28 modelos caben en cada memoria según el nivel que bajes:

Memoria Q8_0 Q5_K_M Q4_K_M Q3_K_M
8 GB 3 5 7 8
12 GB 7 8 9 9
16 GB 9 10 10 12
24 GB 10 16 18 18
32 GB 14 18 20 18

Los equipos son los de nuestro catálogo: un PC con RTX 4060 (8 GB), otro con RTX 3060 (12 GB), un Mac con M4 (16 GB), una estación con RTX 4090 (24 GB) y un Mac mini con M6 (32 GB). Q6_K, fuera de la tabla por espacio, queda en medio: 3, 8, 9, 14 y 17 modelos. Cómo leerla: con 8 GB de VRAM, pasar de Q8_0 a Q4_K_M te lleva de 3 modelos a 7. Con 24 GB, de 10 a 18. La columna de Q3_K_M no siempre crece porque no todos los modelos publican ese nivel: lo tienen 23 de nuestros 28, frente a 26 con Q4_K_M. La memoria que contamos es la que queda para el modelo: 0,8 GiB menos en una tarjeta gráfica para el escritorio y 3 GiB menos en un Mac o en la RAM para el sistema. Otro detalle: la columna de Q3_K_M cuenta lo que cabe, pero el buscador enseña aparte todo lo que queda por debajo de Q4_K_M en vez de contarlo.

Un ejemplo concreto: Qwen3 8B pide 9,99 GiB en Q8_0 con ese contexto, que no caben en la RTX 4060 (7,2 GiB disponibles), y 6,56 GiB en Q4_K_M, que sí. El contexto también cuesta memoria; si vas justo, nuestra guía de longitud de contexto te dice cuánto cuesta cada escalón.

Cómo bajar una cuantización concreta

En Hugging Face, los repositorios oficiales suelen tener un archivo por nivel, y los 3 programas grandes te dejan elegir:

  • llama.cpp: el nivel va detrás de dos puntos. llama-completion -hf Qwen/Qwen2.5-0.5B-Instruct-GGUF:Q4_K_M bajó el archivo de 491.400.032 bytes y respondió en 14,9 segundos, descarga incluida, en nuestra prueba, aunque el nombre del archivo está en minúsculas. Le pedimos en inglés que saludara en español, contestó «¡Hola!» y, sin que nadie se lo pidiera, se pasó al inglés para ofrecer ayuda: bilingüe sí, obediente no tanto. llama-server acepta la misma opción -hf.
  • Ollama: con un modelo de Hugging Face, el mismo patrón: ollama run hf.co/usuario/repositorio:Q4_K_M (esta vía no la probamos hoy). Para cargar un GGUF que ya tienes en disco, FROM ./modelo.gguf en un Modelfile, como contamos en nuestra guía de comandos de Ollama.
  • LM Studio: al bajar un modelo te enseña los archivos del repositorio con su tamaño y eliges uno (no lo probamos esta vez). Si se queja con «no LM runtime found for model format ‘gguf’», el arreglo está en LM Studio no funciona.
Terminal descargando un GGUF Q4_K_M de Hugging Face con llama-completion -hf y el modelo respondiendo
Una orden con :Q4_K_M al final: descarga, respuesta y un archivo de 491.400.032 bytes en la caché Captura: nuestra terminal, llama.cpp b12500, 18-11-2026

Se abre en YouTube (sin cookies) solo si pulsas.

Un vídeo en español de octubre de 2026 que explica qué es un modelo, qué significan 4B u 8B, la cuantización, el formato GGUF y cuánta memoria necesitas.

Qué cuantización GGUF bajar

  • El modelo te cabe con holgura: Q5_K_M o Q6_K. Pierdes casi nada frente a Q8_0 y te queda memoria para el contexto.
  • El caso normal: Q4_K_M. Es el nivel que nuestro buscador toma como referencia, el que convierte 3 modelos en 7 en una tarjeta gráfica de 8 GB, y en nuestra medida tuvo la misma primera opción que el original en el 89 % de los tokens.
  • Te sobra memoria o estás midiendo: Q8_0, que es prácticamente el modelo original a la mitad de tamaño que F16.
  • No te cabe en Q4_K_M: antes de bajar a Q3_K_M, prueba un modelo más pequeño de la misma familia en Q4_K_M o más. Por debajo de Q4_K_M, nuestro buscador te enseña el modelo aparte en vez de contarlo como que cabe.

Si prefieres no hacer las cuentas tú, el buscador de modelos las hace para tu equipo, modelo a modelo, con los mismos números que esta página.