Definición
La quantization (cuantización) es la técnica que reduce la precisión numérica con la que se almacenan los pesos y activaciones de un modelo de IA. Pasa de los típicos 32 bits por parámetro (FP32, el formato original de entrenamiento) a 16 bits (BF16/FP16), 8 bits (INT8), 4 bits (INT4) o incluso menos. El resultado: modelos 2-8× más pequeños, mucho más rápidos en inferencia y con caída de calidad sorprendentemente baja cuando se hace bien.
Sin cuantización, correr Llama 3.1 70B en una sola GPU consumer sería imposible (necesitarías 140GB de VRAM en FP16). Con cuantización a 4-bit, cabe en una sola RTX 4090 de 24GB. Es la técnica que ha hecho viable la IA local en hardware consumer, y la base de formatos como GGUF que han popularizado llama.cpp, LM Studio, Ollama.
Combinado con distillation y LoRA, la cuantización es uno de los tres pilares de la eficiencia operativa moderna de los LLMs.
Cómo funciona
Conceptualmente: cada peso de un modelo es un número decimal. En FP32 ocupa 4 bytes. Si lo aproximamos a uno de 256 valores discretos (INT8), ocupa 1 byte → 4× menos memoria.
La cuantización moderna no es trivial — necesita:
- Determinar el rango: para cada tensor o grupo de pesos, encontrar el min y max reales.
- Mapear a la rejilla cuantizada: cada peso se aproxima al valor cuantizado más cercano. Se guarda también un factor de escala (scale) y un offset (zero point) para reconstruir aproximadamente el valor original.
- Reconstruir en runtime: durante el forward pass, los pesos cuantizados se dequantifican on-the-fly (o se opera directamente en formato cuantizado con kernels optimizados).
La pérdida de precisión es controlable. Para LLMs grandes, INT8 es casi sin pérdida, INT4 pierde ~1-3% en benchmarks, INT2 pierde más pero ya hay modelos sorprendentemente buenos.
Formatos numéricos modernos
| Formato | Bits | Memoria por param | Uso típico |
|---|---|---|---|
| FP32 | 32 | 4 B | Entrenamiento clásico (en desuso en LLMs) |
| BF16 | 16 | 2 B | Entrenamiento e inferencia frontera |
| FP16 | 16 | 2 B | Inferencia, algo de entrenamiento |
| FP8 (E4M3, E5M2) | 8 | 1 B | Entrenamiento e inferencia top moderno (H100, H200) |
| INT8 | 8 | 1 B | Inferencia eficiente, casi sin pérdida |
| INT4 | 4 | 0.5 B | Inferencia local, deploy edge |
| NF4 | 4 | 0.5 B | QLoRA, optimizado para distribución de pesos LLM |
| INT2 | 2 | 0.25 B | Frontera de investigación, pérdida notable |
| 1-bit (BitNet) | 1 | 0.125 B | Investigación, modelos especializados |
Tipos de cuantización
Tres categorías principales:
- Post-Training Quantization (PTQ): cuantizar un modelo ya entrenado, sin reentrenamiento. Rápido, simple. La mayoría de modelos descargables (GGUF, AWQ, GPTQ) son PTQ.
- Quantization-Aware Training (QAT): entrenar (o fine-tunear) el modelo simulando cuantización para que aprenda a ser robusto. Mejor calidad, más coste.
- Mixed precision: algunas capas en alta precisión, otras en baja. Lo más usado en producción top.
Algoritmos PTQ modernos:
- GPTQ: cuantización capa por capa con calibración. Buena calidad, lento de generar.
- AWQ (Activation-aware Weight Quantization): detecta qué pesos son críticos y los preserva en mayor precisión. Excelente balance.
- GGUF (formato de llama.cpp): contenedor que soporta múltiples esquemas de cuantización (Q4_K_M, Q5_K_S, Q8_0, etc.). Estándar de facto para inferencia local.
- HQQ (Half-Quadratic Quantization): rápido, sin calibración, calidad razonable.
Ejemplo práctico
Imagina que quieres correr Llama 3.1 70B localmente en tu Mac Studio para procesar documentos sin que salgan de la empresa.
- FP16 (sin cuantizar): 140 GB de VRAM. Impensable.
- INT8: 70 GB. Solo cabe en estaciones tope (Mac Studio Ultra 192GB, sí).
- INT4 (Q4_K_M): 42 GB. Cabe cómodamente en Mac Studio Max, RTX A6000.
- INT4 más agresivo (Q3_K_M): 32 GB. Cabe en una sola RTX 5090.
La pérdida de calidad medida en benchmarks como MMLU al pasar de FP16 a Q4_K_M es típicamente del 1-2%. Para uso práctico casi indetectable.
En AE Works, para un cliente que necesita asistente local con datos confidenciales: deployamos Qwen 2.5 32B en Q5_K_M en una RTX 4090. Velocidad: 30 tokens/s. Calidad: comparable a GPT-4 Turbo del año pasado para su dominio. Coste mensual: cero (excluyendo electricidad).
Cuantización en entrenamiento vs inferencia
- En entrenamiento: se usa FP32 o BF16 para los gradientes (precisión es crítica para que backprop funcione). FP8 está emergiendo en hardware H100+ para entrenamientos muy grandes.
- En inferencia: aquí es donde la cuantización agresiva (INT4, INT8) brilla. No necesitas precisión perfecta para predecir el siguiente token.
- QLoRA: combinación. Base cuantizado en NF4 (inferencia eficiente), adaptadores LoRA en BF16 (entrenamiento estable).
Hardware específico para cuantización
Las GPUs modernas tienen unidades de cómputo optimizadas para precisión reducida:
- NVIDIA H100/H200: kernels Tensor Core para BF16, FP8, INT8.
- NVIDIA Blackwell B100/B200: FP4 nativo (entrenamiento e inferencia).
- AMD MI300X: FP16, FP8, INT8.
- Apple Silicon (M-series): kernels Neural Engine optimizados, soporte para Q4 vía MLX.
- Groq LPU: especializado para inferencia ultra-rápida en INT8.
A más bajo nivel de precisión, más tokens/s puede procesar el hardware. Por eso la cuantización agresiva mejora dramáticamente la latencia, no solo la memoria.
Errores comunes al hablar de cuantización
- "Siempre pierde calidad notablemente": en LLMs modernos, hasta INT4 la pérdida es marginal en la mayoría de tareas.
- Confundir con compresión clásica: cuantización es matemática de precisión, no zip ni nada por estilo.
- Pensar que es trivial: implementar kernels eficientes en INT4 con dequantización rápida requiere ingeniería sofisticada.
- Ignorar la elección del esquema: Q4_0 puro pierde más que Q4_K_M (que usa cuantización por bloques mejorada).
- Cuantizar y olvidarse de evaluar: siempre mide en tu caso de uso concreto. A veces hay sorpresas.
- Esperar mismo speedup en todas las arquitecturas: depende del hardware y de si los kernels están optimizados para tu formato.
- Confundir tamaño en disco con VRAM activa: la KV cache durante inferencia también consume mucho, y suele estar en mayor precisión.
Cuándo conviene cuantizar
Sí, cuantiza cuando:
- Quieres correr modelos grandes en hardware limitado.
- Necesitas reducir coste/latencia de inferencia a escala.
- Despliegas en edge (móviles, IoT, dispositivos limitados).
- Tu modelo no requiere precisión absoluta extrema.
Es menos crítico cuando:
- Estás entrenando (mantén precisión alta).
- Tu modelo es muy pequeño y la VRAM no es problema.
- Necesitas máxima calidad y el coste no importa.
Referencias
- Frantar et al. · GPTQ paper — cuantización moderna PTQ con calibración
- Lin et al. · AWQ paper — activation-aware quantization
- llama.cpp GGUF spec — el formato de facto para inferencia local