# Cuantización Q4 vs Q8 vs FP16: la diferencia de calidad, medida

> Qwen2.5 7B en Q4_K_M, Q8_0 y FP16 con 40 facturas sintéticas: Q8_0 acertó enteras 8 más que Q4 al 66 % de su velocidad. FP16 no aportó nada.

- Publicado: 2026-11-20
- Autor: Jacobo González Jaspe
- Idioma: es
- Etiquetas: Cuantización, GGUF, Ollama, Benchmarks, IA local
- URL canónica: https://vorluxai.com/blog/q4-q8-fp16-cuantizacion-medido-es/
- Fuente: VORLUX AI (J4SGON S.L.), https://vorluxai.com/

---

Al terminar este artículo sabrás qué fichero descargar para un modelo de 7B, cuánto cuesta cada codificación en memoria y velocidad, y qué falla de verdad Q4_K_M en una tarea real. La prueba cabe en una tarde en cualquier máquina con unos 10 GB libres. Pasamos un mismo modelo en tres codificaciones por las mismas 40 facturas y el mismo prompt de velocidad.

Si quieres aprender a leer el nombre de un fichero GGUF y elegir uno para tu memoria, eso está en nuestra [guía de GGUF](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/). Este artículo es la medición: un modelo, tres ficheros y una tarea con respuestas correctas.

> **En corto**
> - **Te llevas:** Qwen2.5-7B-Instruct en Q4_K_M, Q8_0 y FP16, medido en velocidad, memoria cargada y aciertos en 360 campos de facturas.
> - **Cuesta:** Q8_0 carga 3,1 GB más que Q4_K_M y escribe al 66 % de su velocidad. FP16 pide otros 6,6 GB y va al 59 % de la velocidad de Q8_0.
> - **Veredicto:** para extraer datos como aquí, Q8_0 si te cabe. Acertó enteras 8 facturas que Q4_K_M falló, y ninguna al revés. FP16 no aportó nada.

## La pregunta que todos responden con perplejidad

Casi todas las páginas sobre este tema citan la perplejidad, una medida de lo sorprendido que queda un modelo ante un texto de referencia. Es un buen número de investigación. No te dice si el NIF de una factura volverá con su letra.

Así que usamos una tarea con respuestas correctas. Cuarenta facturas ficticias en español, hechas por un generador con semilla fija: facturas formales, correos, tickets de caja y documentos desordenados como un mal escaneo. El modelo devuelve nueve campos en JSON (número, fecha, emisor, los dos NIF, base, tipo de IVA, cuota y total). Las respuestas salen del generador, así que no las escribió ningún modelo. Las facturas son sintéticas: no medimos la precisión con facturas reales, y nuestro [artículo sobre salida JSON](https://vorluxai.com/blog/ollama-salida-json-facturas-medido-es/) tiene la prueba completa de seis modelos con el mismo conjunto. El conjunto es público: [structured-extraction-es-invoices-2026-11-05.json](https://vorluxai.com/data/measurements/structured-extraction-es-invoices-2026-11-05.json).

## Qué necesitas

- Ollama, y memoria libre para el fichero más grande que quieras probar (Q8_0 de un modelo de 7B ocupó 7,9 GB cargado con 4k de contexto, así que deja unos 10 GB).
- Dos etiquetas del mismo modelo. En Ollama la codificación va en el nombre de la etiqueta; la guía de GGUF enlazada arriba explica cómo leerla.
- Una tarea con respuestas correctas: la nuestra, o diez documentos tuyos.

## Paso 1: descarga dos codificaciones

```bash
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:7b-instruct-q8_0
ollama list | grep qwen2.5:7b-instruct
```

La etiqueta corta `qwen2.5:7b` es el fichero Q4_K_M. Borra después el que no te quedes (`ollama rm`); cada uno ocupa varios gigas en disco.

## Paso 2: mide velocidad y memoria

```bash
for tag in q4_K_M q8_0; do
  curl -s localhost:11434/api/generate -d "{\"model\": \"qwen2.5:7b-instruct-$tag\", \"stream\": false,
    \"prompt\": \"Resume en 150 palabras las obligaciones de un contrato con un proveedor.\",
    \"options\": {\"num_predict\": 200, \"temperature\": 0, \"num_ctx\": 4096}}" \
  | 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 | grep qwen2.5
done
```

Lanza cada una dos veces y quédate con el segundo número: el primero incluye la carga del fichero. `SIZE` en `ollama ps` es la memoria que ocupa el modelo, y también depende de `num_ctx`. Va redondeado y en gigas binarios: nuestro FP16, 14,52 GB en la tabla de abajo, aparece como `14 GB`.

## Paso 3: cuenta qué falla cada uno

Pasa tu tarea por las dos etiquetas con temperatura 0 y compáralas **documento a documento**, no solo por la nota total. Cuenta dos números: documentos que el fichero pequeño falló y el grande acertó, y al revés. Si el reparto está muy desequilibrado, la diferencia es real; si está cerca del empate, es ruido. Con 8 contra 0, como nos salió, un reparto al azar pasaría menos de una vez de cada cien (una prueba de signos a dos colas da 0,008).

## Qué medimos

Medido el 2026-11-05 en nuestra primera DGX Spark (`spark-43d5`, NVIDIA GB10, 128 GB de memoria unificada), Ollama 0.30.10, un modelo cargado cada vez. Velocidad: nuestro prompt estándar de 278 palabras, 200 tokens de salida, temperatura 0, tres ejecuciones, se publica la segunda, contexto por defecto de 32k. Aciertos: las 40 facturas con un esquema JSON en la petición, temperatura 0, `num_ctx` 4096. Ficheros en bruto: [quantization-speed-2026-11-05.json](https://vorluxai.com/data/measurements/quantization-speed-2026-11-05.json) y [structured-extraction-2026-11-05.json](https://vorluxai.com/data/measurements/structured-extraction-2026-11-05.json).

```bash
python3 scripts/bench/run_for_topic.py --host prime --slug quantization-speed \
  --bench "local_model_benchmark.py --models qwen2.5:7b-instruct-q4_K_M,qwen2.5:7b-instruct-q8_0,qwen2.5:7b-instruct-fp16 --runs 3"
python3 scripts/bench/run_for_topic.py --host prime --slug structured-extraction \
  --bench "structured_extraction.py --models qwen2.5:7b-instruct-q4_K_M,qwen2.5:7b-instruct-q8_0,qwen2.5:7b-instruct-fp16"
```

La segunda orden está recortada: la ejecución publicada incluye además otros tres modelos.

**Velocidad y memoria:**

| Codificación | Fichero | Cargado, 4k de contexto | Cargado, 32k de contexto | Generación | Primer token | Carga en frío |
|---|---|---|---|---|---|---|
| Q4_K_M | 4,68 GB | 4,75 GB | 6,59 GB | 42,7 tok/s | 0,28 s | 6,0 s |
| Q8_0 | 8,10 GB | 7,89 GB | 9,74 GB | 28,2 tok/s | 0,32 s | 5,5 s |
| FP16 | 15,24 GB | 14,52 GB | 16,36 GB | 16,5 tok/s | 0,33 s | 9,5 s |

**Aciertos en 40 facturas (con esquema):**

| Codificación | Campos bien (de 360) | Facturas enteras bien | NIF bien (de 80) | Importes bien (de 120) | Segundos por factura |
|---|---|---|---|---|---|
| Q4_K_M | 329 | 26 | 58 | 120 | 3,37 |
| Q8_0 | 344 | 34 | 70 | 120 | 4,96 |
| FP16 | 344 | 34 | 70 | 120 | 8,36 |

Dos datos detrás de las tablas. Q8_0 y FP16 dieron respuestas idénticas byte a byte en 118 de 120 llamadas, contando las tres formas de pedirlo. Q4_K_M devolvió los mismos datos que Q8_0 en 31 de 40 facturas con esquema (27 idénticas byte a byte). De las nueve en las que los datos cambiaron, Q8_0 acertó más campos en ocho; la novena fue un empate, con las dos mal.

## Lo que no te dicen

- **Q4 pierde caracteres, no cuentas.** Las tres versiones acertaron base, IVA y total en todas las facturas. Los 15 campos que Q4_K_M falló de más fueron todos nombres y NIF. Quitó la letra de un NIF en seis facturas, casi siempre escritos en grupos con espacios («A 09 014 170» volvió como «09014170»), y en tres correos más confundió al cliente con el emisor. Un NIF sin letra falla cualquier comprobación posterior.
- **El fichero grande no arregló la lectura.** Q8_0 y FP16 siguieron poniendo al cliente como emisor en 5 de 10 facturas recibidas por correo, las mismas cinco. Más bits no hicieron que el modelo entendiera quién firmaba el correo.
- **La velocidad sigue al tamaño del fichero.** En esta máquina, la generación bajó al crecer el fichero, algo menos que en proporción: 42,7, 28,2 y 16,5 tok/s para 4,7, 8,1 y 15,2 GB. Cada salto fue de 1,7 a 1,9 veces los bytes y de 1,5 a 1,7 veces más lento. El tiempo hasta el primer token apenas cambió.
- **En una GPU con menos memoria que el fichero, nada de esto vale.** Si el modelo se desborda a la CPU, cuenta con que el fichero grande vaya mucho más lento que estas cifras (ese caso no lo medimos). Comprueba que `ollama ps` diga `100% GPU`.

## Veredicto

- **Compra Q8_0** para extraer campos como aquí, donde un carácter importa, cuando el fichero más tu contexto quepan con holgura. Código y conversación no los probamos.
- **Quédate con Q4_K_M** si vas justo de memoria (8 GB o menos) o la velocidad pesa más que las cadenas exactas: es 1,5 veces más rápido y, en esta tarea, sus fallos de más fueron todos en nombres y NIF.
- **Sáltate FP16** en este modelo de 7B. Casi el doble de tamaño que Q8_0, el 59 % de su velocidad y las mismas respuestas en 118 de 120 llamadas.

## Cuándo no hacerlo

Si en tu máquina solo cabe Q4_K_M, la comparación es teórica: la otra opción es un modelo más pequeño en Q8_0, y esa es otra prueba. Si usas el modelo para conversar, puede que la diferencia que medimos ni se note; diez prompts tuyos lado a lado te lo dirán antes. Y esto es un modelo en una tarea. Un modelo más grande u otra familia pueden perder más, o menos, a 4 bits; mide el tuyo antes de fijar un fichero para todo.

## Siguientes pasos

- Lee el nombre de un fichero GGUF y estima tamaños antes de descargar: [cuantización GGUF: elige el fichero adecuado](https://vorluxai.com/blog/gguf-quantization-pick-the-right-file-for-your-hardware-es/).
- Saca un JSON que tu código pueda leer siempre, y puntúalo: [salida JSON estructurada con Ollama, medido](https://vorluxai.com/blog/ollama-salida-json-facturas-medido-es/).
- Suma el contexto al tamaño del fichero antes de comprar: [¿cuánta VRAM necesito para un LLM local?](https://vorluxai.com/blog/cuanta-vram-necesito-llm-local-es/).
- Mira adónde va la memoria cuando crece el contexto: [Ollama num_ctx y memoria, medido](https://vorluxai.com/blog/ollama-longitud-contexto-memoria-medida-es/).

## Trabaja con nosotros

Elegimos el modelo y la máquina midiendo, no adivinando. Si quieres ver tu propia tarea funcionando en hardware real, [reserva una llamada gratuita de 15 minutos](https://vorluxai.com/contact/) o mira [cómo trabajamos en consultoría](https://vorluxai.com/consulting/).
