Cuantización GGUF: elige el archivo de modelo correcto para tu máquina de 8, 16, 24 o 32 GB

Al terminar este artículo sabrás mirar la página de descarga de un modelo, elegir el único archivo que cabe en tu máquina y demostrar con tus propios números que era la elección correcta. Funciona en cualquier portátil con 8 GB de RAM; los comandos son los mismos en una placa de 250 EUR y en nuestra estación de trabajo.

Qué necesitas

• Un ordenador con 8 GB de memoria o más. Una GPU ayuda, pero no es obligatoria.
• Ollama instalado (gratis, sin cuenta). Todo lo que sigue vale también para llama.cpp y LM Studio, que leen los mismos archivos.
• Quince minutos y unos 5 GB de disco para descargar un modelo.
• Opcional: un asistente de IA abierto al lado. Al final hay un prompt que puedes pegarle con tus números.

Paso 1: lee el nombre del archivo

GGUF es el formato de archivo que usan llama.cpp y Ollama. La especificación de ggml lo define como un formato binario pensado para cargar y guardar modelos rápido, y fija el esquema de nombres:

<BaseName><SizeLabel><FineTune><Version><Encoding><Type><Shard>.gguf
Hermes-2-Pro-Llama-3-8B-F16.gguf
Grok-100B-v1.0-Q4_0-00003-of-00009.gguf

Te importan tres partes:

• SizeLabel (8B, 70B): el número de parámetros. Cuanto más grande, más lento y más memoria, sea cual sea la codificación.
• Encoding (Q4_K_M, Q8_0, F16): con cuántos bits se guarda cada peso. F16 son los pesos originales de 16 bits. Q8_0 es 8 bits y Q4_K_M es 4 bits con el método de bloques “K” y la mezcla “M” (media). Según la documentación GGUF de Hugging Face, Q4_K cuesta 4,5 bits por peso y Q5_K cuesta 5,5; los sufijos _S, _M y _L mantienen unas pocas capas sensibles con más precisión. Los tipos IQ (IQ4_XS, IQ2_M) usan una matriz de importancia para apretar un poco más.
• Shard (00003-of-00009): el modelo está partido en varios archivos. Los necesitas todos.

Ollama esconde el archivo detrás de una etiqueta. ollama pull llama3.1:8b te da un archivo Q4_K_M; la página ollama.com/library/llama3.1/tags lista las alternativas, desde 8b-instruct-q2_K hasta 8b-instruct-q8_0 y 8b-instruct-fp16. Puedes comprobar lo que tienes:

ollama show llama3.1:8b
# parameters 8.0B · context length 131072 · quantization Q4_K_M

Paso 2: conoce los tamaños

El proyecto llama.cpp publica el tamaño de cada cuantización de Llama 3.1 8B en su README de quantize; la columna de 70B sale de la tabla GGUF de bartowski para Llama 3.3 70B.

Codificación	Bits por peso	Llama 3.1 8B	Llama 3.3 70B	Qué dice la comunidad de la calidad
Q2_K	3,16	2,95 GiB	26,4 GB	muy baja, “sorprendentemente usable”
Q3_K_M	4,00	3,74 GiB	34,3 GB	baja
IQ4_XS	~4,25	—	37,9 GB	decente, cerca de Q4_K_S
Q4_K_M	4,89	4,58 GiB	42,5 GB	buena, la opción por defecto
Q5_K_M	5,70	5,33 GiB	50,0 GB	alta
Q6_K	6,56	6,14 GiB	57,9 GB	muy alta, casi el original
Q8_0	8,50	7,95 GiB	75,0 GB	prácticamente el original
F16	16,0	14,96 GiB	~141 GB	el original

Para un modelo que no está en la tabla, estima el archivo como parámetros × bits por peso ÷ 8. Un modelo de 14B en Q4_K_M ocupa unos 14 × 4,89 ÷ 8 = 8,6 GB; uno de 32B en Q4_K_M, unos 19,6 GB.

Paso 3: suma la ventana de contexto y compara con tu memoria

El archivo no es toda la historia. El modelo guarda además una caché con todo lo que hay en la conversación actual, y su tamaño depende de la ventana de contexto que permitas, no de la cuantización. Lo medimos en nuestra estación de trabajo (NVIDIA GB10, 128 GB de memoria unificada, Ollama 0.30.10, 09-09-2026) con el mismo archivo llama3.1:8b de 4,9 GB:

num_ctx	Memoria residente (ollama ps)	Velocidad de generación
4.096 tokens	5,3 GB	23,8, 23,2 y 15,8 tokens/s en tres ejecuciones
131.072 tokens	22 GB	20,0 y 24,0 tokens/s en dos ejecuciones

El mismo archivo, cuatro veces más memoria. La regla que sale de aquí: presupuesta el tamaño del archivo más 1 GB para un contexto de 4k, y después alrededor de 1 GB más por cada 8k tokens adicionales en un modelo de 8B, y más en modelos mayores. La ejecución a 15,8 tokens/s coincidió con otro servicio cargando un segundo modelo en la misma máquina compartida; el día anterior, con la máquina tranquila, el mismo modelo dio 37,8 tokens/s. Tus números variarán con la carga, y por eso se mide en vez de fiarse de una tabla.

Con esa regla, esto es lo que cabe en cada sitio, dejando margen para el sistema operativo:

Tu memoria (VRAM de GPU o unificada)	Elección cómoda	Posible con cuidado	No merece la pena
8 GB	8B en Q4_K_M, 3B en Q8_0	8B en Q5_K_M con contexto de 4k	8B en Q8_0, cualquier 14B o mayor
16 GB	8B en Q8_0, 14B en Q4_K_M	14B en Q5_K_M	32B
24 GB	14B en Q8_0, 32B en Q4_K_M	32B en Q5_K_M con contexto corto	70B en cualquier codificación (IQ2_M ya son 24,1 GB sin contexto)
32 GB	32B en Q5_K_M	32B en Q6_K	70B por debajo de IQ4_XS: la pérdida de calidad no compensa
48 a 64 GB	70B en IQ4_XS o Q4_K_M	70B en Q5_K_M con 64 GB	70B en Q8_0

Paso 4: mide tú mismo velocidad y memoria

Descarga dos codificaciones del mismo modelo y cronométralas con el mismo prompt. Ollama devuelve el número de tokens y el tiempo de generación en nanosegundos:

ollama pull llama3.1:8b-instruct-q4_K_M
ollama pull llama3.1:8b-instruct-q8_0

for tag in 8b-instruct-q4_K_M 8b-instruct-q8_0; do
  curl -s localhost:11434/api/generate -d "{
    \"model\": \"llama3.1:$tag\", \"stream\": false,
    \"prompt\": \"Resume en 200 palabras las obligaciones principales de un contrato con un proveedor.\",
    \"options\": {\"num_predict\": 300, \"num_ctx\": 4096, \"temperature\": 0.2}
  }" | python3 -c "import json,sys; d=json.load(sys.stdin); \
    print('$tag', round(d['eval_count']/d['eval_duration']*1e9,1), 'tok/s')"
  ollama ps   # la columna SIZE es la memoria residente de esta etiqueta
done

Salida esperada: dos líneas con tokens por segundo y dos tablas de ollama ps. Si en una máquina con GPU la columna PROCESSOR dice algo distinto de 100% GPU, el archivo no cabía y una parte corre en la CPU; baja un nivel de codificación o reduce num_ctx.

Paso 5: mide la calidad, no solo la velocidad

Velocidad y memoria se leen en un segundo; la calidad necesita una prueba pequeña y tuya. Dos métodos, de barato a riguroso:

1. Diez prompts de tu negocio. Guarda las diez preguntas que tu equipo hace de verdad (una cláusula, una ficha de producto, una consulta SQL). Pásalas por las dos etiquetas con temperature: 0 y pon las respuestas una al lado de la otra. Si no distingues Q4_K_M de Q8_0 en tus tareas, quédate con el archivo pequeño y con la memoria que libera.
2. Perplejidad con llama.cpp. Si compilas llama.cpp, llama-perplexity -m modelo.gguf -f tu-texto.txt da un número por archivo; cuanto más bajo, mejor, y la diferencia entre codificaciones sobre tus propios documentos es el dato que importa.

Prompt para tu asistente, con tus números pegados: “Aquí tienes tokens por segundo, memoria residente y diez pares de respuestas de Q4_K_M y Q8_0. ¿Qué codificación debería dejar en una máquina de 16 GB que atiende a cinco personas, y por qué?”

Dónde encaja

• Un archivo de 4 bits es el valor por defecto correcto. Es lo que Ollama te da al escribir el nombre de un modelo y es lo que usan la mayoría de los benchmarks publicados.
• Sube a Q6_K o Q8_0 cuando el archivo siga cabiendo con tu contexto de trabajo. El código y la extracción de datos estructurados son los casos en los que más se notan los bits extra.
• Baja a Q3 o a los tipos IQ solo para meter un modelo mucho más grande. Un 70B en IQ4_XS en una máquina de 48 GB es un buen cambio; un 8B en Q2_K en una máquina de 8 GB no lo es, porque un 3B en Q8_0 suele responder mejor.

Límite honesto: la cuantización no cambia lo que el modelo sabe ni la longitud de su contexto. Cambia solo la fidelidad con la que se guardan los pesos y la memoria que ocupan.

Siguientes pasos

• Por qué funcionan los 4 bits, con más contexto: La cuantización explicada.
• Dimensiona la máquina antes de comprar: Mejores dispositivos para IA local en 2026.
• Decide si la caja se amortiza: IA en la nube o en local: tu punto de equilibrio.

Trabaja con nosotros

Hacemos esta medición con cada cliente en su propio hardware antes de recomendar un modelo, y publicamos los números que obtenemos. Si quieres una segunda opinión sobre un archivo o una máquina, escríbenos o mira cómo trabajamos en consultoría.