Ver todos los artículos
CuantizaciónGGUFOllamaIA LocalHardware

Cuantización GGUF: elige el archivo correcto para tu máquina

JG
Jacobo González Jaspe
|

Revisado:

Ilustración abstracta: esferas de vidrio anidadas con una luz ámbar en el centro. Modelos
Ilustración generada con IA en nuestra máquina.
Este artículo también está en inglés:GGUF Quantization: Pick the Right File for Your Machine

Al terminar esta guía sabrás abrir la página de descarga de un modelo, elegir el archivo que cabe en tu máquina y comprobar la elección. Basta un portátil con 8 GB de memoria. Herramientas y opciones están contrastadas con el código de llama.cpp y Ollama a 15 de noviembre de 2026.

Qué necesitas

  • Un ordenador con 8 GB de memoria y Ollama. Los nuestros son 0.30.10 y 0.34.0.
  • Solo para el paso 6: llama.cpp compilado (la 1.0.0 salió el 13-11-2026).

Paso 1: lee el nombre del archivo

GGUF es el formato que cargan llama.cpp, Ollama y LM Studio. Su especificación fija los nombres, con las partes unidas por guiones:

texto
[<Sidecar>]<BaseName><SizeLabel><FineTune><Version><Encoding><Type><Shard>.gguf
Grok-100B-v1.0-Q4_0-00003-of-00009.gguf
mmproj-Qwen2-VL-7B-v1.0-F16.gguf
  • SizeLabel (100B): cuántos pesos tiene. Es lo que más mueve memoria y velocidad.
  • Encoding (Q4_0, F16): cómo se guarda cada peso (paso 2).
  • Shard (00003-of-00009): modelo partido: necesitas todos los archivos.
  • Sidecar (mmproj-): un archivo adicional para imágenes o audio, no el modelo.

Algunos autores añaden etiquetas propias. En la página de Llama 3.3 70B de bartowski, Q4_K_L es un Q4_K_M con los pesos de entrada y salida en Q8_0; llama.cpp no tiene ese tipo.

Paso 2: conoce las cuatro familias

FamiliaNombresCómo guarda los pesos
Sin cuantizarF32, F16, BF16Coma flotante original. El origen para cuantizar
Clásica (legacy)Q4_0, Q5_0, Q8_0Bloques de 32 pesos, con redondeo simple
K-quantsQ2_K a Q6_K, con _S _M _LBloques dentro de superbloques, con escalas compactadas
I-quantsIQ1_S a IQ4_XSSuperbloques de 256 pesos, ajustados con una matriz de importancia

La estructura sale de la referencia GGUF de Hugging Face, que da los tipos clásicos por poco usados hoy. Aun así, ollama show llava:7b responde Q4_0 en nuestra máquina.

_S, _M, _L. Un K-quant es una mezcla: unos pocos tensores sensibles llevan más bits de los que dice el nombre. Nuestro Q4_K_M del paso 6 tiene 169 tensores en Q4_K y 29 en Q6_K. _S sube menos.

Una matriz de importancia no es un I-quant. Son datos de calibración: llama-imatrix pasa texto de muestra por el modelo y apunta qué pesos importan. Los K-quants también pueden usarla (PR 4930), con --imatrix en llama-quantize; los archivos de bartowski la llevan todos. No generamos ninguna; los comandos están en el paso 6.

Los I-quants no salen gratis fuera de la GPU. La ficha de bartowski dice que funcionan en CPU y en Apple Metal, pero más despacio que el K-quant de tamaño parecido, y que no funcionan con Vulkan. El aviso está en la ficha de un modelo ya antiguo, así que compruébalo en tu entorno. La tabla de llama.cpp para Llama 3.1 8B da 70,15 tokens por segundo a IQ3_M y 71,68 a Q3_K_M, sin decir en qué equipo. No hemos cronometrado ningún I-quant.

Tipos más recientes. La herramienta lista además TQ1_0 y TQ2_0, para modelos entrenados con pesos de tres valores (PR 8151), y MXFP4_MOE, Q1_0 y Q2_0. No los hemos usado.

Paso 3: conoce los tamaños

TipoQwen2.5 7B, nuestra simulaciónBits por peso, misma ejecuciónLlama 3.1 8B, llama.cppAumento de perplejidad (Llama 3 8B)
IQ2_XS2.348,96 MiB2,592,42 GiBno figura
Q2_K2.870,55 MiB3,162,95 GiB+3,5199
IQ3_M3.402,77 MiB3,753,52 GiBno figura
Q3_K_M3.626,29 MiB3,993,74 GiB+0,6569
IQ4_XS4.047,72 MiB4,464,17 GiBno figura
Q4_04.220,43 MiB4,65no figura+0,4685
Q4_K_S4.245,58 MiB4,684,36 GiB+0,2689
Q4_K_M4.460,45 MiB4,914,58 GiB+0,1754
Q5_K_S5.063,27 MiB5,585,21 GiB+0,1049
Q5_K_M5.186,92 MiB5,715,33 GiB+0,0569
Q6_K5.958,79 MiB6,566,14 GiB+0,0217
Q8_07.717,68 MiB8,507,95 GiB+0,0026

Fuentes: nuestra ejecución, gguf-quantize-run-2026-11-15.json, en la que llama-quantize --dry-run imprimió cada tamaño sin escribir ningún archivo; el README de quantize de llama.cpp para los tamaños de Llama 3.1 8B; y la lista de tipos de la herramienta para la perplejidad (leídos el 15-11-2026). El archivo de origen ocupaba 14.526,27 MiB a 16 bits. Las filas de I-quants se calcularon sin matriz de importancia, e IQ2_XS no se puede generar sin ella.

Dos lecturas. El clásico Q4_0 y Q4_K_S se llevan 25 MiB, y el K-quant pierde bastante menos. Por debajo de Q4 la pérdida sube deprisa.

llama.cpp imprime MiB y GiB; Ollama y Hugging Face muestran GB decimales. Para un modelo sin tabla: tamaño ≈ parámetros × bits por peso ÷ 8. Los bits por peso no son una constante, porque la mezcla de tensores cambia con el modelo: el README de llama.cpp da 4,8944 para Q4_K_M en Llama 3.1 8B, y nuestra ejecución imprimió 4,91 en Qwen2.5 7B. Con 4,89, un 14B ocupa unos 8,6 GB.

Paso 4: calcula si cabe

Un modelo cargado reserva además una caché para la conversación, una por ranura en paralelo. La memoria es el archivo, más contexto por ranuras por un coste por token, más 1 o 2 GB de margen.

Medido el 2-11-2026 con un archivo de 4,9 GB, llama3.1:8b en Q4_K_M, en nuestras dos DGX Spark (GB10, 128 GB de memoria unificada, Ollama 0.30.10 y 0.34.0), según ollama ps. Datos: ollama-num-ctx-2026-11-02.json.

Ranurasnum_ctxTamaño cargado
14.0965,27 GB
132.7689,21 GB
84.0969,15 GB
432.76822,38 GB
832.76839,27 GB

El mismo archivo ocupó entre 5,27 y 39,27 GB: lo que cuenta es ranuras por contexto. No todos los modelos pagan igual: cuánta memoria cuesta el contexto en Ollama. La cuenta a mano: ¿cuánta VRAM necesito?.

Fija tú el contexto. La página de longitud de contexto de Ollama (leída el 15-11-2026) da 4k con menos de 24 GiB de VRAM, 32k hasta 48 GiB y 256k por encima, y su FAQ dice que las peticiones en paralelo lo multiplican. En nuestra segunda Spark ese valor, con ocho ranuras, tumbó las cargas hasta que cada modelo llevó su propio num_ctx.

Encoger la caché en vez del modelo. La FAQ de Ollama documenta OLLAMA_KV_CACHE_TYPE. Por defecto vale f16; q8_0 ocupa más o menos la mitad de la memoria de caché y q4_0 una cuarta parte. Requiere Flash Attention, se aplica a todos los modelos del servidor, y la FAQ avisa de que algunos modelos, Qwen2 entre ellos, pueden perder más precisión. En llama.cpp las opciones son -ctk y -ctv. Reduce solo la parte del contexto, nunca el archivo. No lo hemos probado.

Después ejecuta ollama ps: PROCESSOR debe decir 100% GPU. Si muestra un reparto como el 48%/52% CPU/GPU de la FAQ, baja num_ctx y después la cuantización.

Paso 5: comprueba qué cuantización sirve Ollama

Una etiqueta sin más esconde el archivo. En nuestra máquina (Ollama 0.30.10, 15-11-2026), primer bloque de la salida:

bash
ollama show llama3.1:8b
#   Model
#     architecture        llama
#     parameters          8.0B
#     context length      131072
#     embedding length    4096
#     quantization        Q4_K_M

En un script, lee details.quantization_level de /api/show. Los demás archivos están en la página de etiquetas, de 8b-instruct-q2_K a 8b-instruct-fp16. Ollama también descarga archivos GGUF directamente de Hugging Face. Según la guía del Hub (leída el 15-11-2026):

bash
ollama run hf.co/<usuario>/<repo>          # Q4_K_M si el repositorio lo tiene
ollama run hf.co/<usuario>/<repo>:Q8_0     # una cuantización concreta, en mayúsculas o minúsculas

Si el repositorio no tiene Q4_K_M, el Hub elige otro archivo por ti, así que pide el que quieres; el nombre completo del archivo también vale como etiqueta. No ejecutamos estos comandos.

Paso 6: cuantiza un modelo tú mismo

Solo si nadie publica el archivo que quieres.

bash
git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
cmake -B build && cmake --build build --config Release -j 8
python3 -m pip install -r requirements.txt

# fase 1: pesos de Hugging Face -> GGUF de 16 bits
python3 convert_hf_to_gguf.py /ruta/al/modelo --outfile modelo-f16.gguf --outtype f16
# fase 2: primero el tamaño, después cuantizar con 8 hilos
./build/bin/llama-quantize --dry-run modelo-f16.gguf Q4_K_M
./build/bin/llama-quantize modelo-f16.gguf modelo-Q4_K_M.gguf Q4_K_M 8

Ejecutamos solo la fase 2, con una compilación de julio de 2026. El origen fue el archivo FP16 de Qwen2.5 7B que Ollama guarda en disco; ollama show qwen2.5:7b-instruct-fp16 --modelfile da su ruta en la línea FROM. En nuestra primera DGX Spark, solo con CPU:

texto
llama_model_quantize_impl: model size  = 14526.27 MiB (16.00 BPW)
llama_model_quantize_impl: quant size  =  4460.45 MiB (4.91 BPW)
llama_quantize: quantize time = 46515.99 ms

Un archivo de 15,24 GB pasó a 4,68 GB, el tamaño que Ollama da a su propia etiqueta Q4_K_M. Leído de vuelta, su tipo es 15, MOSTLY_Q4_K_M en la especificación. No lo cargamos. El proceso llegó a 14.885.452 kB de memoria residente, más o menos el tamaño del archivo de origen: el README dice que el modelo se lee entero en memoria, así que cuenta con RAM para el archivo de 16 bits.

Con matriz de importancia. Hace falta para los tipos más pequeños (están con los errores, más abajo) y es opcional para el resto. Del README de imatrix, a 15-11-2026:

bash
# 1. pasa texto de calibración por el modelo de 16 bits; escribe imatrix.gguf
./build/bin/llama-imatrix -m modelo-f16.gguf -f calibracion.txt -o imatrix.gguf -ngl 99
# 2. cuantiza con ella
./build/bin/llama-quantize --imatrix imatrix.gguf modelo-f16.gguf modelo-IQ3_M.gguf IQ3_M 8

-m y -f son obligatorios. -ngl 99 lleva el cálculo a la GPU, que es lo que el README recomienda por velocidad; quítalo si trabajas con CPU. --chunks limita cuánto texto se procesa. bartowski enlaza en su ficha el texto de calibración que usa. No ejecutamos ninguno de los dos comandos: nuestra compilación no trae llama-imatrix y en esta guía solo usamos la CPU.

Sin compilar nada. El README de quantize remite al Space GGUF-my-repo de Hugging Face. Se ejecuta en sus servidores, así que no sirve para pesos que no pueden salir de casa. No lo hemos usado.

Para cargarlo en Ollama: un Modelfile con FROM ./modelo-Q4_K_M.gguf y ollama create mi-modelo. No lo ejecutamos. Cuantiza antes: la página de importación (leída el 15-11-2026) dice que Ollama no cuantiza archivos GGUF, y -q es solo para safetensors en el código actual. Para comparar la calidad, mira llama-perplexity.

Qué medimos

Qwen2.5 7B Instruct en tres archivos, 5-11-2026, primera DGX Spark, Ollama 0.30.10. Velocidad con un prompt de 278 palabras; precisión con 40 facturas sintéticas. Datos: quantization-speed-2026-11-05.json y structured-extraction-2026-11-05.json.

CodificaciónArchivoGeneraciónFacturas sin ningún error
Q4_K_M4,68 GB42,7 tok/s26 de 40
Q8_08,10 GB28,2 tok/s34 de 40
FP1615,24 GB16,5 tok/s34 de 40

Q8_0 acertó ocho facturas más al 66 % de la velocidad de Q4_K_M. FP16 no añadió nada. Es un modelo y una tarea; el análisis está en Q4, Q8 o FP16, medido.

Lo que no te dicen

  • «requantizing from type q4_K is disabled». Nos salió al pedir Q3_K_M a partir de un Q4_K_M. Parte del archivo de 16 bits: la precisión no se recupera. --allow-requantize lo fuerza. La simulación no lo detectó.
  • «this quantization requires an importance matrix!». Nos salió al pedir IQ2_XS sin matriz. El código la exige para los I-quants de 1 y 2 bits, IQ3_XXS y Q2_K_S.
  • La simulación solo avisa. Con la misma petición de IQ2_XS, --dry-run imprimió un tamaño, salió con 0 y avisó de que completarla «will require an imatrix».
  • Un modelo partido abierto por el archivo equivocado. bartowski parte todo lo que pasa de 50 GB, y su tabla marca también como partido el Q5_K_M de 49,95 GB. El cargador de llama.cpp lanza illegal split file idx con la indicación «model must be loaded with the first split». Deja todos los trozos en la misma carpeta, con su nombre original, y apunta al -00001-of-. Para tener un solo archivo: llama-gguf-split --merge primer-trozo.gguf unido.gguf (README). La página de importación de Ollama admite un comodín, FROM /ruta/al/modelo-*.gguf. El texto del error sale del código; no lo reprodujimos.
  • El servidor de llama.cpp cuenta distinto. Ahí -c es un total que las ranuras comparten o dividen (código). Además, --fit viene activado: según el README del servidor, ajusta los argumentos que no hayas fijado para que quepan en la memoria del dispositivo, deja 1.024 MiB libres por dispositivo y no baja de 4.096 tokens. Allí un contexto sin fijar significa «todo lo que quepa», mientras que Ollama va por tramos. Fíjalo con -c. No lo ejecutamos.

Tabla de decisión por memoria

«Memoria» es la que el modelo puede usar: la VRAM, o la memoria unificada menos el sistema. Los tamaños «cargado» son nuestros, con una ranura salvo indicación; el resto son de archivo.

MemoriaCómodoJusto: contexto corto, una ranuraDescarta, y por qué
8 GB8B Q4_K_M (5,27 GB cargado, 4k)8B Q5_K_M (5,33 GiB)8B Q8_0 (7,95 GiB): no deja sitio al contexto
12 GB7B Q8_0, 4k (7,89 GB cargado)7B Q8_0, 32k (9,74 GB cargado)14B a 32k: el nuestro cargó 15,29 GB
16 GB14B Q4_K_M (8,99 GB)24B Q4_K_M (14,33 GB)7B FP16 (15,24 GB): misma nota que Q8_0 en nuestra prueba
24 GB26B Q4_K_M (17,47 GB cargado, 32k)32B Q4_K_M (unos 19,6 GB por fórmula)70B IQ2_XXS (19,10 GB): bartowski lo califica de calidad muy baja
32 GB35B Q4_K_M (23,47 GB cargado, ocho ranuras de 32k)70B Q2_K (26,38 GB)70B Q3_K_S (30,91 GB): la ficha lo desaconseja, y no queda margen
48 GB70B IQ4_XS (37,90 GB)70B Q4_K_M (42,52 GB)70B Q5_K_S (48,66 GB): el archivo solo ya la llena
64 GB70B Q5_K_M (49,95 GB)70B Q6_K (57,89 GB)70B Q8_0 (74,98 GB): no cabe, y la ficha dice que rara vez hace falta

El contexto decide: nuestro 14B cargó 15,29 GB a 32k. Nuestras cifras: dgx-spark-review-prime-2026-11-02.json, mistral-small-24b-speed-ctx4k-2026-11-15.json, structured-extraction-2026-11-05.json y el archivo de num_ctx. Los tamaños de 8B y 70B son de llama.cpp y de bartowski. No hemos ejecutado un 70B: esas filas dejan uno o dos gigas libres, como aconseja bartowski.

Cuándo no hacerlo

  • No cuantices tú si un repositorio mantenido ya publica el archivo. Te ahorras compilar, descargar los 16 bits y calibrar.
  • No bajes de 4 bits para arañar un poco. Sirve para meter una clase de modelo que de otro modo no podrías ejecutar, y entonces lo pruebas.
  • No bajes a Q4 sin medir en trabajos donde un dígito mal es una respuesta mal: en nuestra prueba de facturas costó ocho documentos de 40.
  • No recuantices un archivo ya cuantizado. Vuelve al origen de 16 bits.
  • No cambies de cuantización para arreglar un problema de memoria sin haber fijado antes num_ctx y las ranuras. En el paso 4 movieron el mismo archivo de 5,27 a 39,27 GB.
  • No sirvas en FP16. Guárdalo como origen para nuevas cuantizaciones.

Veredicto

  • Compra: Q4_K_M por defecto. La etiqueta llama3.1:8b es ese archivo.
  • Compra: Q8_0 para extraer datos donde un carácter importa, si cabe con margen.
  • Espera: I-quants hasta que un modelo mayor no quepa de otro modo. Entonces compáralo con el pequeño en Q4_K_M.
  • Sáltatelo: FP16 para ejecutar, y no cuantices tú cuando un repositorio mantenido ya tenga el archivo.

Preguntas frecuentes

¿Basta con Q4_K_M? Es el punto de partida habitual: llama.cpp le apunta +0,1754 de perplejidad en Llama 3 8B. En nuestra tarea de extracción acertó 26 facturas frente a las 34 de Q8_0. Depende de la tarea, así que prueba la tuya.

¿Un archivo más pequeño va más rápido? En nuestra prueba, sí: 42,7 tokens por segundo en Q4_K_M, 28,2 en Q8_0 y 16,5 en FP16. La tabla de llama.cpp para Llama 3.1 8B va en el mismo sentido (71,93, 50,93 y 29,17).

¿Un modelo mayor con menos bits o uno menor con más? No lo hemos medido. La perplejidad de dos modelos distintos no se puede comparar, así que la respuesta honrada es ejecutar tu propia tarea con los dos.

¿Puedo convertir un Q4 de vuelta en Q8? No. llama-quantize se niega, y si lo fuerzas obtienes un archivo mayor con los errores del Q4 dentro. Descarga el archivo grande.

¿Necesito una matriz de importancia? Solo para los tipos que se niegan a generarse sin ella. En los K-quants es opcional, y los archivos de bartowski ya la llevan.

¿Q4_K_M, Q4_K_S o Q4_0? En nuestro 7B, Q4_K_S ahorra 215 MiB frente a Q4_K_M y Q4_0 ahorra 240, con un aumento de perplejidad de +0,2689 y +0,4685 en lugar de +0,1754 en la lista de llama.cpp. Quédate con Q4_K_M salvo que esos megas decidan si cabe.

¿Por qué el tamaño cargado es mayor que el archivo? Por la caché de contexto, una por ranura. Está en el paso 4.

Siguientes pasos

Trabaja con nosotros

Hacemos esta medición en el hardware de cada cliente antes de recomendar un modelo. Para una segunda opinión sobre un archivo o una máquina, escríbenos o mira cómo trabajamos en consultoría.

Diagrama
Compartir: LinkedIn X
Veredicto semanal

Recibe las guías nuevas antes que nadie

Suscríbete y te avisamos cuando publiquemos guías, plantillas y workflows nuevos. Un correo a la semana, sin spam.

Ya publicados: 101 guías y 25 plantillas. Todo gratis y sin registro.

Bonus: el kit de inicio de IA local en PDF al suscribirte
1x por semana Sin spam Cancela cuando quieras

Ver qué recibes