Cuantización: cómo la aritmética del silencio permite ejecutar un 70B en tu portátil
Reduce un modelo de 70B a 35GB sin perder casi precisión. Te explicamos cómo funciona la cuantización: INT8, INT4, GPTQ, AWQ y por qué tu portátil puede con lo que antes requería un cluster.
Si alguna vez te has preguntado cómo diablos puedes ejecutar un modelo de 70 mil millones de parámetros en un portátil que no tiene una GPU de 8.000 euros, la respuesta es una técnica con nombre discreto: cuantización. Reduce el tamaño del modelo hasta 4 veces con una pérdida de calidad casi imperceptible. Y es una de las técnicas más importantes para que la IA sea accesible fuera de los hyperscalers.
El problema base
Los modelos de IA almacenan sus "conocimientos" en matrices de números. Cada número se guarda con una precisión: lo habitual es FP32 (32 bits por número, coma flotante) o FP16 (16 bits). Un modelo de 70B parámetros en FP32 ocupa 280 GB. En FP16, 140 GB. Ningún portátil del mundo aguanta eso.
La cuantización consiste en representar esos mismos números con menos bits. Si paso de FP16 a INT8 (8 bits por número), el modelo pasa de 140 GB a 70 GB. Si voy a INT4, son 35 GB. Ahí ya sí cabe en un portátil con 64 GB de RAM.
La pregunta clave: ¿pierde calidad el modelo? La respuesta corta es: depende de cómo lo hagas.
FP32, FP16, INT8, INT4: qué significa cada cosa
Para entender la cuantización hay que entender las precisiones. FP32 (float de 32 bits) ofrece ~7 dígitos decimales de precisión. FP16 ofrece ~3-4 dígitos. BF16 (brain float) sacrifica precisión por rango, útil para entrenamiento.
Los formatos enteros (INT8, INT4) son diferentes: no tienen coma flotante. Representan números en un rango fijo (por ejemplo, INT8 va de -128 a 127). Para cuantizar, hay que mapear el rango original de los pesos al rango del formato entero, y guardar los parámetros de ese mapeo (escala y zero-point).
valor_int8 = round(valor_float / escala) + zero_point
El truco está en elegir bien la escala: si es muy grande, perdemos precisión. Si es muy pequeña, nos quedamos sin rango y muchos valores se colapsan al mismo entero.
Cuantización uniforme: el caso simple
La versión más simple usa una escala única para toda la matriz de pesos. Es rápida y fácil de implementar, pero subóptima: las matrices de un modelo tienen pesos con distribuciones muy diferentes, y aplicar la misma escala a todas desperdicia rango donde no hace falta.
Por eso la cuantización moderna usa cuantización por canal o por grupo: una escala diferente para cada fila de la matriz, o para grupos de 128 pesos. Más parámetros de escala, pero mucha mejor calidad.
GPTQ, AWQ, GGUF: los algoritmos que importan
En la práctica, no se cuantiza "a lo loco". Hay algoritmos que optimizan la cuantización para minimizar el error:
GPTQ
Quantización por capas usando información de segundo orden (matriz Hessiana). Procesa el modelo capa por capa, ajustando los pesos ya cuantizados para compensar el error introducido. Es el algoritmo detrás de la mayoría de modelos "GPTQ" que ves en Hugging Face.
AWQ (Activation-aware Weight Quantization)
Observa qué pesos se activan más con datos reales y protege esos de la cuantización (los guarda con más bits). El resto se cuantiza agresivamente. Es más rápido que GPTQ y produce modelos casi idénticos en calidad.
GGUF (de llama.cpp)
Es un formato de archivo, no un algoritmo, pero se ha vuelto estándar para modelos cuantizados que corren en CPU. Lo creó Georgi Gerganov para su proyecto llama.cpp y permite que un modelo cuantizado se ejecute en una Raspberry Pi si hace falta.
El trade-off real
Más cuantización = menos memoria = menos calidad. La curva se ve así:
- FP16 → INT8: pérdida de calidad mínima (típicamente <1% en benchmarks), ahorro de 2x memoria. Casi siempre vale la pena.
- INT8 → INT4: pérdida de calidad notable en tareas difíciles (matemáticas, código complejo), pero aceptable para conversación. 2x más ahorro de memoria.
- INT4 → INT2: territorio experimental. El modelo se degrada mucho, pero hay investigación interesante sobre si arquitecturas específicas lo toleran mejor.
Para un modelo de 70B, lo razonable hoy es INT4: cabe en un Mac con 64 GB de RAM unificada, corre a ~5-10 tokens/segundo, y la calidad es usable para la mayoría de tareas.
Lo que viene
La investigación en cuantización está activa. Cuantización mixta (diferentes precisiones para diferentes capas según su sensibilidad) es la siguiente frontera. Cuantización durante el entrenamiento (QLoRA, QAT) permite entrenar modelos grandes en hardware modesto. Y cuantización extrema (1-bit, 1.58-bit con BitNet) está demostrando que se puede ir más allá de lo que creíamos posible.
Si quieres probar la cuantización por ti mismo, llama.cpp, AutoGPTQ y bitsandbytes son los tres puntos de entrada más prácticos. Elige un modelo pequeño (Llama 3.2 1B o Qwen 2.5 1.5B), cuantízalo a INT4, y verás cómo pasa de "no cabe" a "cabe y vuela".