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. Este artículo es la medición: un modelo, tres ficheros y una tarea con respuestas correctas.
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 tiene la prueba completa de seis modelos con el mismo conjunto. El conjunto es público: 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
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:7b-instruct-q8_0
ollama list | grep qwen2.5:7b-instructLa 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
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
doneLanza 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 y structured-extraction-2026-11-05.json.
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 psdiga100% 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.
- Saca un JSON que tu código pueda leer siempre, y puntúalo: salida JSON estructurada con Ollama, medido.
- Suma el contexto al tamaño del fichero antes de comprar: ¿cuánta VRAM necesito para un LLM local?.
- Mira adónde va la memoria cuando crece el contexto: Ollama num_ctx y memoria, medido.
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 o mira cómo trabajamos en consultoría.