Cuarto y último módulo del bloque básico del Curso de GPU para IA. En el Módulo 2 apareció la promesa: un modelo de 16 GB puede caber en 5. Hoy se cumple. La cuantización es la tecnología que hace viable toda la IA local — y entender sus niveles es lo que te permitirá elegir bien cada modelo que descargues.

La tesis del módulo

La cuantización es el puente entre el modelo que quieres y la GPU que tienes. Reducir la precisión de los pesos de 16 bits a 4 achica el modelo a un tercio con una pérdida de calidad que en el uso normal casi no se percibe. No es un truco sucio: es el estándar de la IA local.

Qué es la precisión de un parámetro

Cada parámetro del modelo es un número, y guardar un número cuesta bits. Cuántos bits uses define la precisión:

Formato	Bits	Bytes/parámetro	Un modelo 8B ocupa
FP32	32	4	~32 GB — el formato de entrenamiento clásico
FP16 / BF16	16	2	~16 GB — el estándar de inferencia “completa”
INT8 / Q8	8	1	~8.5 GB — pérdida imperceptible
~4 bits / Q4	~4.5	~0.6	~4.9 GB — el punto dulce de lo local

(FP16 y BF16 usan los mismos 16 bits repartidos distinto; para efectos de tamaño son equivalentes. Los tamaños reales de abajo incluyen partes del modelo que no se cuantizan por igual — por eso “Q4” pesa un poco más que 4 bits exactos.)

Por qué funciona: la intuición

Un LLM tiene miles de millones de parámetros y una enorme redundancia: el “conocimiento” está repartido y ningún peso individual es crítico. Redondear cada peso a una escala más gruesa mete un poco de ruido — y la red, que ya era robusta al ruido, apenas lo nota.

La analogía: comprimir una foto a JPEG. Bien hecho, nadie distingue el original; exagerado (calidad 10%), aparecen los bloques. En modelos, la degradación se mide con métricas como la perplexity (qué tan “sorprendido” queda el modelo ante texto real: menor es mejor) — y de Q8 a Q4 el aumento es mínimo. Bajo Q4, empieza la pendiente resbalosa.

 mismo modelo 8B, distinta precisión

 FP16    ████████████████  ~16 GB   calidad de referencia
 Q8_0    █████████         ~8.5 GB  pérdida imperceptible
 Q6_K    ███████           ~6.6 GB  prácticamente intacta
 Q5_K_M  ██████            ~5.7 GB  pérdida mínima
 Q4_K_M  █████             ~4.9 GB  el punto dulce
 Q2_K    ███               ~3.2 GB  se nota la pérdida

GGUF: el formato que vas a ver en todas partes

GGUF es el formato de archivo del ecosistema llama.cpp/Ollama: el modelo completo, ya cuantizado, en un solo archivo. Cuando descargues modelos verás sufijos como Q4_K_M. Se decodifican así:

Q4 — bits por peso (aquí, ~4).
K — la familia “K-quants”: cuantización inteligente que da más bits a las capas más sensibles en vez de repartir parejo. Es la generación buena; prefiérela.
S / M / L — small, medium, large: variantes dentro del nivel. M es el equilibrio habitual.

Ojo: el nombre no lo dice, pero hay una pieza que NO viene cuantizada: el KV cache (módulo 2) se guarda por defecto en 16 bits. Un modelo chico con contexto enorme puede gastar más VRAM en cache que en pesos.

La regla práctica para elegir

Parte por Q4_K_M. Es el consenso del ecosistema: 3× más chico que FP16, calidad casi intacta. Por algo es el default de Ollama.
¿Te sobra VRAM? Sube a Q5_K_M, Q6_K o Q8_0. La mejora existe, aunque es sutil.
¿No te alcanza ni con Q4? Antes de bajar a Q3/Q2, considera un modelo más chico bien cuantizado: un 8B en Q4 suele responder mejor que un 14B estrangulado en Q2.
Mientras más chico el modelo, más le duele cuantizar. Un 70B aguanta Q3 con dignidad; un 3B en Q3 se resiente. La redundancia que protege es proporcional al tamaño.

La cuenta completa, de una vez

Con todo el bloque básico encima, ya puedes dimensionar de verdad. Para el clásico “quiero correr un 8B en mi RTX de 12 GB”:

pesos (8B en Q4_K_M)         ~4.9 GB
KV cache (contexto 8k)       ~1.0 GB
buffers y overhead           ~0.5 GB
────────────────────────────────────
total                        ~6.4 GB   →  cabe con margen ✓

Esa es exactamente la cuenta que Ollama hace por ti — y que ahora sabes auditar con nvidia-smi cuando algo no calce.

Errores comunes

Juzgar un modelo probándolo en Q2. Estás probando su versión lobotomizada. Las comparaciones justas se hacen en Q4 o más.
Creer que Q4 es “un cuarto de la inteligencia”. La relación bits/calidad no es lineal: 4 bits conservan la gran mayoría de la capacidad.
Descargar FP16 “porque es el bueno” sin tener VRAM. Si no cabe, no corre — o corre en CPU a paso de tortuga. El bueno es el que cabe con margen.
Ignorar la K. Entre Q4_0 (vieja escuela) y Q4_K_M (K-quants) hay diferencia de calidad real al mismo tamaño.
Olvidar el contexto en la cuenta. La cuantización achica los pesos; el KV cache sigue creciendo igual con cada token de conversación.

Cierre del bloque básico

Ya tienes el mapa completo del hardware: qué es una GPU y sus tipos (M1), cómo dimensionar memoria y velocidad (M2), la torre de software que lo hace funcionar (M3) y el formato en que los modelos se hacen portátiles (M4). Todo lo que viene se apoya en esto.

La frase para llevarse

“Cuantizar es comprimir sabiduría: 16 bits guardan el conocimiento con lujo de detalle, 4 bits guardan lo esencial — y lo esencial, casi siempre, es todo lo que necesitas.”

Qué viene

Arranca el bloque intermedio (Módulo 5): dejamos la teoría y corremos tu primer LLM local con Ollama — instalación, descarga de un modelo, chat en terminal y la API compatible con OpenAI que usarás desde tus agentes.

GPU para IA — Módulo 4: precisión y cuantización