Cuantización de LLMs: AutoRound, GPTQ y AWQ en 2026

La cuantización de LLMs es el proceso de comprimir los pesos de un modelo de lenguaje desde representaciones de alta precisión (FP32 o FP16) a formatos de menor bit-width como INT8, INT4 o incluso INT2, reduciendo el consumo de memoria entre un 50% y un 75% con una pérdida de precisión medible y controlable. Intel AutoRound, publicado en EMNLP 2024 Findings, introduce SignRound: un algoritmo basado en descenso de gradiente con signo que logra ~97% de accuracy retenida en cuantización 4-bit, completando la compresión de un modelo de 72B parámetros en aproximadamente 37 minutos.

¿Qué es la cuantización de LLMs y por qué importa?

Ponele que querés correr Llama 3.1 70B en tu servidor. En FP32 puro necesitás unos 140 GB de VRAM. En FP16 seguís necesitando 70 GB. La mayoría de los equipos no tienen eso disponible, o si lo tienen, el costo de inferencia es brutal. La cuantización de LLMs resuelve ese problema comprimiendo los pesos del modelo a representaciones de menor precisión: INT8 (8 bits), INT4 (4 bits) o incluso INT2 (2 bits por peso).

No es una técnica nueva. Lleva años usándose en redes neuronales de visión. Pero los LLMs modernos introdujeron complejidades nuevas: distribuciones de pesos irregulares, valores atípicos en las activaciones, sensibilidad distinta por capa. Los métodos viejos de cuantización uniforme perdían demasiada precisión. La evolución reciente, y AutoRound en particular, ataca exactamente eso.

El impacto práctico es claro: menos VRAM, menor latencia, menor costo por token generado. Para equipos que despliegan modelos en producción, esos números se traducen en cuántas instancias necesitás levantar y cuánto pagás por hora.

Algoritmo SignRound: cómo Intel AutoRound resuelve la cuantización

El problema central de cuantizar pesos no es solo elegir cuántos bits usar, sino decidir cómo redondear cada valor al representante más cercano en el nuevo espacio discreto. Los métodos anteriores usaban heurísticas simples o aproximaciones costosas. AutoRound de Intel propone algo distinto: tratar esa decisión de redondeo como un problema de optimización y resolverlo con gradiente.

SignRound es el núcleo. En vez de calcular gradientes completos (caro, lento), usa solo el signo del gradiente para actualizar las decisiones de redondeo: si el gradiente dice “subí este peso”, subís; si dice “bajalo”, bajás. Eso hace que cada paso sea liviano. El resultado: según el blog oficial de Hugging Face sobre AutoRound, el proceso completo para un modelo de 72B tarda alrededor de 37 minutos con solo 200 pasos de optimización y un dataset de calibración de 128 muestras.

Lo que optimiza AutoRound no son solo los pesos, sino también los rangos de recorte (clipping ranges). Ajusta simultáneamente qué valores “caen dentro” del rango cuantizable y cómo se redondean los que quedan adentro. Eso es lo que le da ventaja en precisión ultra-low-bit, especialmente INT2, donde otros métodos colapsan y AutoRound sigue siendo usable.

El paper fue presentado en EMNLP 2024 Findings (noviembre 2024), lo que le da peso académico real. No es solo un repositorio suelto en GitHub. Esto se conecta con lo que analizamos en en infraestructuras empresariales de modelos.

Comparativa: AutoRound, GPTQ y AWQ

Los tres son métodos de cuantización post-entrenamiento (PTQ), o sea, no requieren reentrenar el modelo. Las diferencias importan cuando elegís qué herramienta usar en producción.

GPTQ es el método más antiguo de los tres y sigue siendo el más usado para deployment en CPU gracias al ecosistema GGML/GGUF. El problema es el tiempo: para modelos de 70B, calcular las matrices de Hessian por capa puede tomar horas. AWQ es más rápido y funciona bien, pero pierde algo en los rangos ultra-low-bit. AutoRound ocupa el medio: no tan rápido como AWQ en hardware limitado, pero notablemente más preciso en INT2 y más rápido que GPTQ para modelos grandes.

¿Cuál usar? Si necesitás INT4 en producción y tenés GPUs razonables, AutoRound o AWQ. Si necesitás correr el modelo cuantizado en CPU o en un entorno GGUF, GPTQ sigue siendo el estándar.

Impacto real: precisión y rendimiento en 4-bit vs 8-bit

Los datos concretos vienen de un estudio de Red Hat que corrió más de medio millón de evaluaciones sobre LLMs cuantizados. Las conclusiones son bastante claras:

• INT8: menos del 1% de pérdida de accuracy, 50% de reducción de memoria. Casi siempre vale la pena.
• INT4: entre 1.8% y 2.9% de pérdida de accuracy, 75% de reducción de memoria, 2.4x más rápido en inferencia.
• INT2: pérdida variable según el método, pero AutoRound la mantiene controlada. No recomendado para todos los casos sin validación previa.

Un dato que se pasa por alto con frecuencia: los modelos más grandes toleran mejor la cuantización. Un modelo de 7B cuantizado a INT4 puede degradar notoriamente en tareas de razonamiento. El mismo proceso aplicado a un modelo de 70B pierde proporcionalmente menos. Tiene sentido intuitivo: hay más parámetros que “absorber” la pérdida de resolución.

Para ponerlo en términos de infraestructura: Llama 3.1 405B en FP16 necesita ~810 GB de VRAM (varios nodos). Cuantizado a INT4, entra en dos A100 de 80 GB. Eso no es solo ahorro de costo, es la diferencia entre poder deployarlo o no.

Implementación práctica: herramientas y flujo básico

AutoRound está disponible en PyPI. La instalación es `pip install auto-round`. El flujo básico tiene tres pasos: calibración, cuantización y validación. Para más detalles técnicos, mirá como ocurre en ChatGPT.

Para quienes trabajan con bitsandbytes (el método más simple), el camino más corto es cargar el modelo con `load_in_4bit=True`, especificar `bnb_4bit_compute_dtype=torch.bfloat16` y `bnb_4bit_quant_type=”nf4″`. Eso cuantiza el modelo on-the-fly en la carga, sin proceso de calibración previo (spoiler: conveniente, pero menos preciso que un método post-entrenamiento dedicado).

Para AutoRound específicamente, el paper describe el proceso en tres fases: primero preparar el dataset de calibración (el tamaño mínimo recomendado es 128 muestras), luego correr la optimización SignRound (200 pasos por defecto), y finalmente exportar el modelo cuantizado en el formato objetivo (AutoGPTQ, AutoRound nativo, o GGUF para deployments en CPU).

Las integraciones disponibles al momento incluyen vLLM, SGLang y Transformers de Hugging Face. Si tu stack ya usa alguno de esos, la incorporación es directa.

Casos de uso: cuándo cuantizar tiene sentido

Deployment en GPUs consumer o mid-range es el caso más obvio. Si tenés una RTX 4090 con 24 GB, un modelo de 13B en FP16 no entra. Cuantizado a INT4 ocupa ~7 GB y corre perfectamente.

Fine-tuning con recursos limitados

QLoRA combina cuantización INT4 con adaptadores LoRA de baja precisión para permitir fine-tuning de modelos grandes en hardware consumer. Un modelo de 65B se puede afinar con QLoRA en una sola GPU de 48 GB, algo imposible con el modelo completo en FP16.

Reducción de costos en cloud

Si deployás LLMs en infraestructura propia (servidores con GPU, VPS de alta memoria), la cuantización reduce directamente el costo por token. Menos VRAM por instancia, más peticiones concurrentes por nodo. Para quien hospeda sus propios modelos, por ejemplo en servidores dedicados vía donweb.com con GPU disponible, el impacto en el presupuesto mensual es inmediato.

Vision-Language Models (VLMs)

AutoRound tiene soporte explícito para VLMs, lo que no es común en otros métodos. Si trabajás con modelos multimodales (texto + imagen), eso amplía las opciones considerablemente.

Errores comunes al cuantizar LLMs

Dataset de calibración inadecuado. Si las 128 muestras de calibración no representan la distribución de texto que el modelo va a procesar en producción, la cuantización optimiza para el conjunto equivocado. El resultado es un modelo que puntúa bien en benchmarks generales pero falla en tu caso de uso específico. La corrección: usá muestras del dominio real del modelo deployado. Más contexto en en la optimización de modelos de lenguaje.

No validar post-cuantización. Cuantizás el modelo, lo exportás, lo ponés en producción. Parece que anda. Tres semanas después alguien nota que las respuestas en ciertos prompts largos son raras. La degradación no siempre aparece en los benchmarks estándar. Siempre corré tus propias evaluaciones sobre casos de uso reales antes de ir a producción.

Asumir que INT2 funciona sin más. AutoRound lo permite técnicamente y lo hace mejor que cualquier otro método en ese rango, pero eso no significa que sea transparente. ¿Cuánto tiempo toma cuantizar un modelo grande con AutoRound? Para 72B son ~37 minutos en INT4. En INT2 el proceso puede ser más largo y la validación post-cuantización es obligatoria. No lo uses en producción sin un ciclo de pruebas dedicado.

Ignorar el overhead inicial. La cuantización con AutoRound o GPTQ es un proceso que lleva tiempo y recursos. Si tu flujo de CI/CD reconstruye el modelo cuantizado en cada deploy, vas a tener un problema. El modelo cuantizado hay que versionarlo y cachearlo, no regenerarlo.

Usar bitsandbytes para todo. bitsandbytes es conveniente para prototipado rápido, pero no es lo mismo que una cuantización PTQ dedicada. Para producción, AutoRound o GPTQ dan resultados más reproducibles y exportables.

Preguntas Frecuentes

¿Qué es la cuantización de LLMs y por qué es importante?

La cuantización de LLMs convierte los pesos del modelo de alta precisión (FP32/FP16) a formatos de menor bit-width como INT8 o INT4, reduciendo el uso de memoria entre 50% y 75%. Importa porque permite deployar modelos grandes en hardware con VRAM limitada, reduce la latencia de inferencia hasta 2.4x en INT4, y baja directamente el costo por token generado en producción.

¿Cuánta precisión se pierde cuando cuantizás un modelo a 4-bit?

Con métodos modernos como AutoRound, la pérdida en INT4 está entre 1.8% y 2.9% de accuracy en benchmarks estándar. Los modelos grandes (70B+) degradan proporcionalmente menos que los modelos chicos (7B-13B). Para la mayoría de los casos de uso en producción, esa pérdida es aceptable dado el ahorro de 75% en VRAM y el gain de velocidad. Cubrimos ese tema en detalle en en los modelos de Google.

¿Cómo funciona el algoritmo SignRound de Intel AutoRound?

SignRound trata la decisión de redondeo de pesos como un problema de optimización. En vez de calcular gradientes completos (costoso), usa solo el signo del gradiente para actualizar iterativamente cómo se redondea cada peso. Con 200 pasos de optimización y 128 muestras de calibración, logra ~97% de accuracy retenida en INT4. El proceso completo para un modelo de 72B toma aproximadamente 37 minutos.

¿Cuál es la diferencia entre AutoRound, GPTQ y AWQ?

GPTQ usa matrices de Hessian para estimar el impacto de cada redondeo, lo que lo hace preciso pero lento para modelos grandes (puede tomar horas para 70B). AWQ se basa en la importancia de las activaciones y es más rápido. AutoRound optimiza conjuntamente el redondeo y los rangos de recorte con descenso de gradiente por signo, siendo más preciso en INT2 y más rápido que GPTQ para modelos grandes. Para CPU deployment con GGUF, GPTQ sigue siendo el estándar.

¿Cuánto tiempo toma cuantizar un modelo grande con AutoRound?

Según los benchmarks oficiales, AutoRound tarda aproximadamente 37 minutos para un modelo de 72B parámetros usando la configuración por defecto (200 pasos, 128 muestras de calibración). Eso es significativamente menos que GPTQ para el mismo tamaño. Para modelos de 7B-13B el proceso es considerablemente más corto, en el orden de los 5-10 minutos dependiendo del hardware.

Conclusión

La cuantización de LLMs pasó de ser una técnica de nicho a un requisito práctico para quien trabaja con modelos grandes en producción. Los números son concretos: INT8 ahorra 50% de memoria con impacto mínimo en precisión, INT4 ahorra 75% y acelera 2.4x la inferencia a cambio de 1.8-2.9% de degradación. Para la mayoría de los casos de uso, ese trade-off es razonable.

AutoRound con SignRound agrega algo real al ecosistema: cuantización INT4 competitiva completada en 37 minutos para modelos de 70B+, soporte para VLMs, e integración directa con los frameworks más usados. El hecho de que el paper haya pasado por EMNLP 2024 Findings le da un respaldo que muchos repos de GitHub no tienen.

Lo que cambia esto: los equipos que antes postergaban el deployment de modelos grandes por falta de VRAM ahora tienen opciones técnicas sólidas. La barrera ya no es el hardware, sino cuánto tiempo le dedicás a validar el modelo cuantizado antes de mandarlo a producción (que, dicho esto, es tiempo bien invertido).

Fuentes

• Intel AutoRound — repositorio oficial con documentación y ejemplos
• Hugging Face Blog — AutoRound: cuantización avanzada de LLMs
• Paper EMNLP 2024: AutoRound y SignRound, descripción técnica completa
• Red Hat — Más de medio millón de evaluaciones sobre LLMs cuantizados
• NVIDIA Developer Blog — Optimización de LLMs con Post-Training Quantization