⏱️ Lectura: 12 min
Los modelos de lenguaje más capaces ocupan cientos de gigabytes y, en teoría, exigen servidores con varias GPU de gama alta. Sin embargo, hoy podés correr un modelo de 70.000 millones de parámetros en una laptop con 48 GB de RAM. La técnica que lo hace posible se llama cuantización de modelos, y es una de las que más ha democratizado la inteligencia artificial en los últimos años.
📑 En este artículo
En esta guía vas a entender, desde cero y con analogías claras, qué es la cuantización, cómo convierte números de 16 bits en números de 4 bits sin que el modelo se vuelva inútil, y cómo aplicarla vos mismo con unas pocas líneas de código.
TL;DR
- La cuantización reduce la precisión numérica de los pesos de un modelo: de 16 bits (FP16) a 8, 4 o incluso 2 bits.
- Un LLM de 70B en FP16 ocupa unos 140 GB; cuantizado a 4 bits baja a ~40 GB y cabe en una sola GPU o laptop con 48 GB.
- La idea central: la mayoría de los pesos no necesitan tanta precisión para producir buenas respuestas.
- Métodos populares: GPTQ, AWQ, bitsandbytes (NF4) y el formato GGUF de llama.cpp para correr en CPU.
- QLoRA permite incluso afinar modelos cuantizados a 4 bits en una sola GPU de consumo.
- El costo es una pérdida de calidad: suele ser pequeña en modelos grandes y más notoria en modelos pequeños.
- Regla práctica de VRAM: bits por peso ÷ 8 × número de parámetros ≈ gigabytes necesarios.
¿Qué es la cuantización de modelos?
Un modelo de lenguaje no es más que una enorme colección de números llamados pesos. Un modelo de 8.000 millones de parámetros tiene, literalmente, 8.000 millones de esos números. Cada peso describe qué tan fuerte es la conexión entre dos neuronas artificiales, y juntos codifican todo lo que el modelo aprendió durante el entrenamiento.
Por defecto, cada uno de esos números se guarda con mucha precisión: 16 bits (el formato FP16 o BF16) o incluso 32 bits. La cuantización de modelos consiste en representar esos mismos pesos con menos bits —típicamente 8, 4 o hasta 2—, de modo que el modelo entero ocupe mucho menos espacio en memoria y se ejecute más rápido.
La mejor analogía es la de una fotografía. Una foto RAW de una cámara profesional guarda cada píxel con enorme detalle de color y pesa decenas de megabytes. Si la exportás a un JPG, el archivo se reduce diez veces y, a simple vista, casi no notás la diferencia. La cuantización es el JPG de los modelos de IA: tira información que el ojo (en este caso, el usuario) difícilmente percibe, a cambio de un archivo mucho más manejable.
💭 Clave: un peso almacenado en FP16 puede tomar miles de valores distintos. Cuantizado a 4 bits, solo puede tomar 16 valores posibles (2⁴). La magia está en elegir bien esos 16 niveles.
Cómo funciona por dentro
Para entender el mecanismo necesitamos un repaso rápido de cómo una computadora guarda números. Un peso en FP16 usa 16 bits para representar un decimal con signo, parte entera y parte fraccionaria. Eso permite valores muy finos, como 0,03719. La cuantización a enteros (por ejemplo INT8 o INT4) reemplaza ese decimal por un número entero pequeño más una fórmula para reconstruir el valor original aproximado.
El truco se basa en dos parámetros por cada grupo de pesos: una escala (scale) y un punto cero (zero-point). La escala dice cuánto vale cada escalón entero; el punto cero alinea el rango. Con ellos, reconstruir un peso es tan simple como: valor_aproximado = escala × (entero - punto_cero). El modelo guarda el entero pequeño (4 bits) y la fórmula recupera un valor cercano al original en el momento de calcular.
El paso delicado es elegir bien la escala. Si en un bloque de pesos hay un valor atípico gigante (un outlier), arrastra toda la escala y los demás pesos pierden resolución. Por eso los métodos modernos no cuantizan todo por igual: identifican el pequeño grupo de pesos verdaderamente importantes y los protegen, mientras comprimen agresivamente el resto. Esa asimetría es la razón de que un modelo en 4 bits pueda quedar a uno o dos puntos del original en la mayoría de las pruebas.
Hay dos grandes momentos para cuantizar. La cuantización post-entrenamiento (PTQ) se aplica a un modelo ya entrenado, a veces usando un pequeño conjunto de datos de calibración para medir los rangos reales de activación. El entrenamiento consciente de cuantización (QAT) simula la pérdida de precisión durante el propio entrenamiento, para que el modelo aprenda a convivir con ella. Para LLMs, lo más común hoy es PTQ porque reentrenar es carísimo.
graph LR
A["Pesos FP16 (16 bits)"] --> B["Calibracion con datos"]
B --> C["Cuantizar a INT4"]
C --> D["Pesos comprimidos (4 bits)"]
D --> E["Dequantizar en inferencia"]
E --> F["Salida del modelo"]En la práctica, el flujo es el que muestra el diagrama: se parte de los pesos originales, se calibran los rangos, se comprimen a enteros pequeños y, en cada paso de inferencia, esos enteros se reconstruyen al vuelo a un decimal aproximado para hacer las multiplicaciones. Todo esto ocurre de forma transparente: el usuario solo nota que el modelo ahora cabe en su tarjeta gráfica.
Métodos y formatos más usados
Existen varios algoritmos de cuantización de modelos, y conviene conocer los nombres porque te los vas a topar al descargar pesos de Hugging Face.
- bitsandbytes (NF4) — La forma más sencilla de cargar un modelo en 4 u 8 bits directamente desde la librería
transformers. NF4 (NormalFloat 4) es un tipo de dato diseñado para pesos con distribución normal. Ideal para empezar. - GPTQ — Cuantización post-entrenamiento que recorre los pesos capa por capa minimizando el error con ayuda de datos de calibración. Muy popular para 4 bits con buena calidad.
- AWQ (Activation-aware Weight Quantization) — Identifica los pesos más salientes a partir de las activaciones y los preserva. Suele dar excelente relación calidad/tamaño y es rápido en inferencia.
- GGUF — No es un algoritmo sino un formato de archivo, el que usa
llama.cpp. Empaqueta el modelo cuantizado (en niveles como Q4_K_M, Q5_K_M, Q8_0) para correr eficientemente en CPU o GPU modestas. Es el formato detrás de herramientas como Ollama y LM Studio.
💡 Tip: si ves un modelo terminado en Q4_K_M, el 4 indica los bits, la K es un esquema de cuantización por bloques mejorado y la M significa tamaño medio. Q4_K_M es el punto dulce entre tamaño y calidad para uso general.
Ejemplo práctico: cargar un modelo en 4 bits
Veamos lo fácil que es en código. Con la librería transformers de Hugging Face y bitsandbytes, cargar un modelo de 8B cuantizado a 4 bits en una GPU de consumo cabe en pocas líneas:
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch
# Configuracion de cuantizacion a 4 bits con NF4
config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-3.1-8B-Instruct",
quantization_config=config,
device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
entrada = tokenizer("Explica que es la cuantizacion en una frase:", return_tensors="pt").to(model.device)
salida = model.generate(**entrada, max_new_tokens=60)
print(tokenizer.decode(salida[0], skip_special_tokens=True))Sin la línea load_in_4bit=True, ese modelo de 8B en FP16 pediría unos 16 GB de VRAM. Con 4 bits, baja a alrededor de 5-6 GB, lo que entra cómodamente en una tarjeta de gama media. La opción bnb_4bit_use_double_quant incluso cuantiza las propias constantes de escala, ahorrando un poco más de memoria.
¿Y cómo estimar la memoria de cualquier modelo? Con la regla práctica: GB ≈ (bits_por_peso / 8) × parámetros. Un modelo de 70B en 4 bits sería (4 / 8) × 70 = 35 GB, más algo de sobrecarga para la caché de contexto. Por eso decimos que ronda los 40 GB.
Casos de uso reales
La cuantización de modelos no es un truco de laboratorio: sostiene buena parte del ecosistema de IA local y eficiente que existe hoy.
- IA en tu propia máquina — Herramientas como Ollama, LM Studio o llama.cpp dependen de GGUF para que cualquiera corra modelos potentes sin enviar datos a la nube, algo clave para privacidad y trabajo sin conexión.
- Reducción de costos de inferencia — En producción, servir un modelo en 8 bits en lugar de 16 puede duplicar el número de peticiones por GPU, recortando la factura de cómputo a la mitad.
- Afinado accesible con QLoRA — La técnica QLoRA combina un modelo base cuantizado a 4 bits con adaptadores LoRA entrenables, permitiendo personalizar modelos grandes en una sola GPU de consumo en lugar de un clúster.
- IA en el borde (edge) — Modelos cuantizados corren en teléfonos, Raspberry Pi y microcontroladores, donde la memoria y la energía son recursos escasos.
Este último punto conecta con una preocupación creciente del sector: el consumo energético de la IA. Menos bits significan menos datos moviéndose entre memoria y procesador, y el movimiento de datos es justamente lo que más energía gasta en la inferencia. La cuantización es, de hecho, una de las palancas más directas para hacer la IA más sostenible.
Ventajas y desventajas
Como toda técnica de compresión, la cuantización implica un compromiso. Conviene tenerlo claro antes de aplicarla a ciegas.
Ventajas: reduce drásticamente el uso de memoria (hasta 4 veces al pasar de 16 a 4 bits); acelera la inferencia porque hay menos datos que mover; baja el costo de cómputo y el consumo energético; y democratiza el acceso, ya que pone modelos enormes al alcance de hardware modesto.
Desventajas: siempre hay una pérdida de precisión. En modelos grandes (30B, 70B y más) suele ser casi imperceptible, pero en modelos pequeños (1B, 3B) puede notarse en tareas de razonamiento o matemáticas. Además, la calidad depende mucho del método y del nivel: bajar a 2 bits sin cuidado puede degradar seriamente el modelo.
⚠️ Ojo: no cuantices a la ligera un modelo pequeño que ya está al límite de su capacidad. Cuanto más chico el modelo, menos margen tiene para perder precisión. Probá siempre la versión cuantizada en tus propias tareas antes de llevarla a producción.
La recomendación general es clara: para modelos grandes, 4 bits (Q4_K_M o equivalente) es casi gratis en calidad; para modelos medianos, 5 u 8 bits da más margen; y si la tarea es crítica y sensible a la precisión, conviene comparar contra el original en FP16 antes de decidir.
📖 Resumen en Telegram: Ver resumen
Preguntas frecuentes
¿La cuantización vuelve más tonto al modelo?
Lo hace ligeramente menos preciso, no tonto. En modelos grandes la diferencia frente al original suele ser de uno o dos puntos en los benchmarks, imperceptible en la mayoría de los usos. En modelos muy pequeños sí puede notarse en tareas exigentes de razonamiento.
¿Cuál es la diferencia entre cuantizar a 4 y a 8 bits?
Con 8 bits el modelo ocupa la mitad que en FP16 y la pérdida de calidad es mínima. Con 4 bits ocupa una cuarta parte, pero la compresión es más agresiva. Para la mayoría de modelos grandes, 4 bits con un buen método (GPTQ, AWQ, NF4) ofrece el mejor equilibrio.
¿Necesito una GPU cara para usar modelos cuantizados?
No necesariamente. El formato GGUF, mediante llama.cpp, permite correr modelos cuantizados en CPU usando RAM normal, aunque más lento. Con una GPU de consumo de 8 a 24 GB ya podés correr modelos de 7B a 30B sin problemas.
¿Puedo entrenar un modelo cuantizado, no solo usarlo?
Sí, con técnicas como QLoRA. La idea es mantener el modelo base congelado en 4 bits y entrenar solo unos adaptadores pequeños (LoRA) por encima. Así podés afinar modelos grandes en una sola GPU de consumo.
¿Qué significan los sufijos como Q4_K_M o Q8_0?
Son niveles de cuantización del formato GGUF. El número indica los bits por peso, la K señala un esquema por bloques mejorado y la letra final (S, M, L) el tamaño relativo. Q4_K_M es la opción más recomendada para uso general por su equilibrio.
¿La cuantización afecta la longitud de contexto?
No directamente: cuantiza los pesos, no el contexto. Pero al liberar memoria, deja más espacio para la caché de claves y valores (KV cache), lo que en la práctica te permite usar ventanas de contexto más largas en el mismo hardware.
Referencias
- Hugging Face — Quantization overview — Guía oficial de los métodos de cuantización soportados en transformers.
- QLoRA: Efficient Finetuning of Quantized LLMs (arXiv 2305.14314) — Paper que introduce NF4 y el afinado en 4 bits.
- GPTQ (arXiv 2210.17323) — Cuantización post-entrenamiento precisa para modelos generativos.
- AWQ: Activation-aware Weight Quantization (arXiv 2306.00978) — Método que preserva los pesos salientes según las activaciones.
- llama.cpp en GitHub — Implementación de referencia del formato GGUF para inferencia eficiente.
📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.
0 Comentarios