Guías de IA · 11 min de lectura

¿Qué es la cuantización en IA? Cómo los modelos de 4 y 8 bits reducen la memoria

La cuantización guarda los pesos de un modelo de IA en 4 u 8 bits para ahorrar memoria. Descubre el impacto en la precisión y la función de GGUF.

Una red cristalina luminosa y dispersa a la izquierda se compacta en un conjunto más apretado de bloques densos a la derecha, sobre fondo oscuro y sin texto ni logotipos

La cuantización en IA es una técnica de compresión que almacena los pesos de un modelo, y a veces sus activaciones, con menos bits para que necesite menos memoria. Al pasar de pesos de 16 bits a una cuantización de 8 o 4 bits, un modelo de 8B pasa de unos 16GB a unos 8GB o 4–5GB solo para los pesos, a cambio de cierta pérdida de precisión y una menor huella de memoria.

Cuando reviso tarjetas de modelos para su despliegue local, aparecen una y otra vez las mismas etiquetas: 8 bits, 4 bits, GPTQ, AWQ y GGUF. Cada una se refiere a una forma distinta de representar números dentro de una red neuronal para que el modelo quepa en una sola GPU, un portátil o una instancia de servidor más pequeña.

¿Cómo reduce la cuantización de modelos el uso de memoria?

La cuantización de modelos reduce la memoria al disminuir el número de bits asignados a cada parámetro en las matrices de pesos del modelo. En noviembre de 2026, la visión general de cuantización de Hugging Face señala que los modelos suelen cargarse en bf16, que ocupa 2 bytes por parámetro. Según la regla orientativa de Hugging Face para los pesos solamente, un modelo de 8B parámetros necesita unos 16GB para sus pesos en bf16, unos 8GB a 8 bits y unos 4–5GB a 4 bits.

Este ejemplo de 8B es una regla orientativa solo para los pesos, no un presupuesto completo de VRAM para ejecutar inferencia. La memoria real del servicio también incluye activaciones, sobrecarga de ejecución y la caché clave-valor que almacena el historial de atención a lo largo del prompt y la salida. Si planeas servir contextos largos, nuestra guía sobre qué es una caché KV explica por qué la memoria crece con la longitud de la secuencia.

Según el cálculo básico de almacenamiento, cada reducción del ancho de bits disminuye los bytes brutos necesarios por parámetro:

Formato de precisión Almacenamiento por parámetro (cálculo) Huella relativa de los pesos frente a BF16
FP32 4 bytes 2x
FP16 / BF16 2 bytes 1x
FP8 / INT8 1 byte 0.5x
FP4 / INT4 / 4 bits de tipo NVFP4 0.5 bytes 0.25x (más la sobrecarga del formato)

Estas cifras de bytes describen un cálculo de almacenamiento bruto, no una prueba comparativa de velocidad real o calidad de salida. En igualdad de condiciones, pasar de BF16 a 8 bits reduce a la mitad la memoria de los pesos, mientras que pasar de BF16 a 4 bits la reduce aproximadamente a una cuarta parte. El intervalo de 4–5GB para un modelo de 8B tiene en cuenta los metadatos de cuantización y la sobrecarga del formato. Como afirma Hugging Face, menos bits cuestan algo de precisión y cada método de cuantización plantea un compromiso diferente entre memoria, velocidad y precisión.

Dos formas de cargar modelos cuantizados en la práctica

Los checkpoints cuantizados entran en una canalización de inferencia o ajuste fino mediante dos procesos de carga distintos, según si la compresión se realiza sobre la marcha o de antemano.

  1. Cuantizar un checkpoint de precisión completa mientras se carga. En Hugging Face Transformers, se pasa un objeto de configuración de cuantización a from_pretrained junto con un checkpoint estándar. Por ejemplo, la documentación oficial muestra cómo cargar meta-llama/Llama-3.1-8B-Instruct en 4 bits pasando BitsAndBytesConfig(load_in_4bit=True, ...). La mayoría de los métodos durante la carga omiten los datos de calibración, aunque GPTQ es la excepción porque se calibra con un conjunto de datos mientras carga el modelo.
  2. Cargar un checkpoint ya cuantizado. Cuando un checkpoint ya se ha comprimido y guardado, se carga sin pasar una nueva configuración de cuantización. Transformers lee los detalles de cuantización del archivo config.json del repositorio o de un archivo GGUF indicado por nombre. Métodos como AWQ, AutoRound, AQLM, compressed-tensors y GGUF solo admiten este proceso en Transformers: se parte de un checkpoint cuantizado previamente con la biblioteca propia del método. Así se distribuyen muchas versiones de los modelos de pesos abiertos en 2026.

Métodos de cuantización habituales: bitsandbytes, GPTQ, AWQ y GGUF

Los métodos habituales de cuantización de modelos se diferencian en cuándo se ejecuta la compresión, qué anchos de bits y hardware admiten, y si están destinados a canalizaciones de Transformers o a entornos de ejecución locales independientes.

Método / formato Proceso en Transformers Anchos de bits / tipo numérico Hardware en la documentación de HF Nota operativa principal
bitsandbytes Cuantizar al cargar o cargar uno guardado 4 bits y 8 bits CUDA, XPU, HPU, CPU Sin calibración; admite ajuste fino
GPTQ Precuantizado o calibrar al cargar 4 bits (de int4 a fp16 sobre la marcha) CUDA, XPU, CPU Necesita un conjunto de calibración; usar GPT-QModel
AWQ Solo precuantizado 4 bits CUDA, XPU, CPU Conserva pesos importantes mediante activaciones
GGUF Solo precuantizado (gguf_file) De 1 a 8 bits CUDA, MPS, XPU, CPU Archivo único; estándar en llama.cpp y Ollama
NVFP4 / FP8 de grano fino Cuantizar al cargar (según el hardware) Coma flotante de 4 / 8 bits GPU NVIDIA (NVFP4 en Blackwell) Representación de coma flotante

bitsandbytes

La guía de selección de métodos de Hugging Face recomienda bitsandbytes cuando se quiere hacer caber un modelo en menos memoria con la mínima configuración. Cuantiza a 4 u 8 bits durante la carga sin un conjunto de datos de calibración, funciona en CUDA, XPU, HPU y CPU, y admite tanto el guardado como el ajuste fino. Según la documentación de bitsandbytes, el modo de 8 bits usa LLM.int8() y reduce a la mitad la memoria de los pesos. El modo de 4 bits hace posible QLoRA, que comprime los pesos a 4 bits y mantiene el modelo entrenable al insertar un pequeño conjunto de pesos entrenables de adaptación de rango bajo (LoRA).

GPTQ

GPTQ es un método de cuantización posterior al entrenamiento que comprime cada fila de una matriz de pesos de forma independiente para minimizar el error de reconstrucción. Según la documentación de GPTQ de Hugging Face, los pesos se cuantizan a int4 y se restauran a fp16 sobre la marcha durante la inferencia. Esto puede reducir el uso de memoria cuatro veces porque los pesos int4 se descuantizan en un núcleo fusionado en lugar de en la memoria global de la GPU; los anchos de bits menores también tardan menos en comunicarse. Ejecutar la cuantización GPTQ requiere un conjunto de datos de calibración y un tokenizador, como en GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer) en la documentación. Transformers ya no admite AutoGPTQ y dirige a los usuarios a GPT-QModel.

AWQ

AWQ, siglas de Activation-aware Weight Quantization, se centra en proteger el pequeño subconjunto de pesos que más importa para la calidad de salida. Como explica la documentación de AWQ de Hugging Face, AWQ conserva una pequeña fracción de los pesos importantes para el rendimiento del LLM a fin de comprimir un modelo a 4 bits con una degradación mínima del rendimiento. En Transformers, AWQ solo está disponible precuantizado y carga checkpoints creados con llm-awq o autoawq.

GGUF

GGUF es un formato de archivo único que reúne los pesos, la configuración y el tokenizador de un modelo en un solo archivo en lugar de utilizar un config.json separado. Por eso Transformers pide un argumento gguf_file explícito. En herramientas locales como llama.cpp y Ollama, GGUF es el formato de los archivos con etiquetas como Q4_K_M y admite pesos precuantizados de 1 a 8 bits en CUDA, MPS, XPU y CPU.

Una advertencia importante se aplica específicamente a Transformers: Hugging Face señala que la mayoría de los modelos GGUF se descuantizan a precisión completa al cargarse en Transformers y usan tanta memoria como un modelo sin cuantizar, salvo una excepción limitada que usa MPS y núcleos en algunos modelos Qwen3.5. Ese comportamiento corresponde al cargador GGUF de Transformers; los entornos locales como llama.cpp y Ollama están diseñados para ejecutar directamente los pesos GGUF cuantizados.

Formatos de coma flotante de pocos bits: FP8, NVFP4 y MXFP8

La cuantización de pocos bits también se extiende a los formatos de coma flotante, diferentes de los formatos enteros como INT8 e INT4. La guía de selección de Hugging Face enumera FP8 de grano fino, MXFP4 y NVFP4, que cuantiza al formato de coma flotante de 4 bits de NVIDIA en GPU Blackwell durante la carga. También existen decenas de otros esquemas, incluidos torchao, HQQ y compressed-tensors, todos catalogados en la guía de selección de Transformers.

¿Qué diferencia hay entre cuantizar solo los pesos y la cuantización completa?

La cuantización de solo pesos comprime las matrices de parámetros almacenadas y deja las activaciones y la caché KV en una precisión mayor, salvo que esos componentes se cuantifiquen por separado. Muchas canalizaciones populares de inferencia con GGUF de 4 bits y de solo pesos almacenan pesos de ancho reducido en memoria y descuantizan o calculan multiplicaciones de matrices en un formato más amplio.

Durante la generación de textos largos, las activaciones y la caché KV siguen consumiendo RAM de la GPU o del sistema junto con los pesos. Hugging Face documenta la cuantización de la caché KV como un paso de optimización independiente para secuencias largas. La arquitectura también determina la memoria total: incluso en los diseños dispersos que cubre nuestra explicación de Mixture of Experts, todos los expertos enrutados y compartidos deben residir en memoria, aunque solo se ejecute una fracción por token.

¿En qué se diferencia la cuantización posterior al entrenamiento del entrenamiento nativo de pocos bits?

La cuantización posterior al entrenamiento parte de un checkpoint terminado de alta precisión y lo comprime después, mientras que el entrenamiento nativo de pocos bits entrena y despliega el modelo directamente en formatos numéricos de pocos bits. GPTQ, AWQ, la mayoría de las conversiones GGUF y bitsandbytes durante la carga pertenecen a la categoría posterior al entrenamiento y aceptan cierto error de conversión una vez terminados el preentrenamiento y la alineación.

El entrenamiento nativo de pocos bits elimina ese paso de conversión posterior. Un ejemplo actual es Inkling 2 Mini, publicado por Thinking Machines Lab el 20 de noviembre de 2026. Según el anuncio oficial de Inkling 2 Mini y la tarjeta del modelo, el modelo de 26.4B parámetros ocupa aproximadamente 20GB de memoria y se entrenó con NVFP4 de 4 bits en sus capas de expertos durante todas las pasadas hacia delante, desde el preentrenamiento hasta el aprendizaje por refuerzo, además de MXFP8 de 8 bits en las pasadas hacia delante de las últimas cuatro capas.

Thinking Machines Lab afirma que los pesos de Inkling 2 Mini se despliegan con la misma precisión numérica con la que se entrenaron —20 capas en NVFP4 y 4 en MXFP8—, por lo que no hay pérdida de conversión por cuantización. Esto significa que no se pierde precisión al convertir un checkpoint BF16 terminado a 4 bits después del entrenamiento; no es una comparación con un gemelo BF16 separado. Las recomendaciones de hardware del equipo incluyen Apple silicon con 32GB de memoria o más, GPU con 32GB de VRAM o más, o un solo NVIDIA DGX Spark.

¿Qué enfoque de cuantización se adapta a tu trabajo?

La elección de un método de cuantización depende del entorno de ejecución, el hardware y de si necesitas ajustar el modelo o solo ejecutar inferencia. Como cada método ofrece distintos compromisos entre memoria, velocidad y precisión según la tarea, ningún ancho de bits sirve para todas las cargas de trabajo.

  • Elige bitsandbytes si quieres cargar un checkpoint existente de precisión completa en 4 u 8 bits con una configuración mínima, o si planeas hacer ajuste fino con QLoRA.
  • Elige GPTQ o AWQ si quieres un checkpoint de 4 bits ya calibrado o que tenga en cuenta las activaciones, creado para inferencia.
  • Elige GGUF si quieres un checkpoint portátil de archivo único para entornos locales como llama.cpp u Ollama.
  • Elige checkpoints nativos de pocos bits cuando el desarrollador de un modelo distribuya pesos entrenados directamente en NVFP4, FP8 o MXFP8.

Comprueba siempre la licencia del modelo antes de convertir o redistribuir pesos cuantizados y deja margen de memoria para la caché KV y la sobrecarga de ejecución. Si tu objetivo es reducir las facturas de inferencia en la nube en lugar de hacer caber los pesos en hardware local, consulta las estrategias de prompts y enrutamiento de nuestra guía sobre cómo reducir los costes de las API de IA.

FAQ

¿La cuantización de 4 bits siempre reduce la calidad de forma perceptible?

Ninguna regla predice el impacto exacto de la cuantización de 4 bits en la calidad para todos los modelos y tareas. Según la documentación de cuantización de Hugging Face, menos bits cuestan algo de precisión y cada método ofrece un compromiso diferente entre memoria, velocidad y precisión. Métodos como AWQ y GPTQ buscan limitar el error teniendo en cuenta las activaciones o mediante calibración, mientras que el ancho de bits, la arquitectura del modelo y la carga de trabajo también determinan el resultado.

¿Por qué un modelo de 8B y 4 bits necesita más de 4–5GB de VRAM total?

La cifra de 4–5GB para un modelo de 8B y 4 bits es una regla orientativa de Hugging Face solo para los pesos, no un presupuesto completo para el servicio. Ejecutar un modelo también requiere memoria para activaciones, sobrecarga de ejecución y la caché KV, que crece con la longitud del prompt y de la generación. Cuantizar los pesos reduce la huella estática del modelo, pero los contextos largos siguen requiriendo una planificación de memoria independiente.

¿Qué diferencia hay entre GGUF y GPTQ o AWQ?

GGUF es un formato de archivo único que reúne pesos, configuración y tokenizador para entornos locales como llama.cpp y Ollama, y admite checkpoints precuantizados de 1 a 8 bits. GPTQ y AWQ son métodos de cuantización de 4 bits que suelen almacenarse en checkpoints con estructura de directorio y un archivo config.json. GPTQ calibra cada fila de la matriz de pesos y AWQ conserva los pesos críticos según las activaciones.

¿Cargar un archivo GGUF en Transformers ahorra memoria?

La mayoría de los archivos GGUF no ahorran memoria al cargarse con Hugging Face Transformers. Según la visión general de cuantización de Hugging Face, la mayoría de los modelos GGUF se descuantizan a precisión completa durante la carga en Transformers y ocupan tanta memoria como un modelo sin cuantizar, salvo una excepción limitada con núcleos MPS en algunos modelos Qwen3.5. Las aplicaciones locales como llama.cpp y Ollama evitan ese comportamiento de Transformers.

¿Qué es NVFP4 en comparación con la cuantización INT4?

NVFP4 es el formato de coma flotante de 4 bits de NVIDIA compatible con el hardware Blackwell, mientras que INT4 representa los pesos como enteros de 4 bits. Ambos formatos almacenan cada parámetro en 0.5 bytes y reducen el almacenamiento bruto de pesos de forma similar a la cuantización entera de 4 bits. Los formatos de coma flotante como NVFP4 y MXFP8 de 8 bits también pueden usarse directamente durante el entrenamiento y el despliegue, como ocurre con Inkling 2 Mini de Thinking Machines Lab.

Fuentes

Escrito por

Chunyu Cai

Chunyu Cai es el director ejecutivo de Lotook, LLC y un emprendedor que escribe sobre modelos de IA, agentes y cómo cambian el trabajo cotidiano. Chunyu Cai tiene un título de máster de Imperial College London.