Fundamentos de la cuantización de modelos

Qué cubre este artículo sobre cuantización

• Qué es la cuantización y por qué importa.
• Diferencias entre formatos de 4 bits, 8 bits y otros.
• Cómo la cuantización afecta la calidad y velocidad.
• Formatos como GGUF, AWQ, GPTQ y EXL2.
• Herramientas y buenas prácticas para empezar.

Introducción: Fundamentos de la cuantización de modelos

Los grandes modelos de lenguaje contienen miles de millones de parámetros, típicamente almacenados como números de punto flotante de 32 bits. Un modelo de 70B requiere más de 250 GB solo para los pesos. La cuantización reduce la precisión de estos números para disminuir significativamente el tamaño del modelo, el consumo de RAM y la carga computacional. A menudo, la calidad se mantiene sorprendentemente alta.

La IA local se beneficia enormemente de la cuantización. Muchos modelos pueden ejecutarse en hardware de consumidor una vez reducidos a 4 bits o menos. Comprender los fundamentos permite elegir el formato adecuado para tu configuración.

¿Qué es la cuantización?

La cuantización es la reducción del número de bits utilizado para almacenar los pesos y activaciones del modelo. En lugar de usar 32 bits por parámetro, se emplean 8 bits o 4 bits. Esto reduce los requisitos de memoria y ancho de banda, acelera los cálculos y permite ejecutar modelos en hardware más limitado.

Ejemplo:

• Un modelo de 7B con 32 bits ocupa aproximadamente 28 GB.
• El mismo modelo con 4 bits ocupa aproximadamente 4 GB.

Por qué usar cuantización

• Menor uso de memoria: Los modelos caben en GPUs y CPUs más pequeñas.
• Mayor velocidad: Se necesita cargar y procesar menos datos.
• Más modelos simultáneamente: Mantén varios modelos en memoria al mismo tiempo.
• Mejor eficiencia: Menor consumo de energía.
• Posibles pérdidas de calidad: Cuanta más agresiva sea la cuantización, mayor el riesgo.

Términos clave

• FP32: Punto flotante de 32 bits, alta precisión, alto consumo de memoria.
• FP16: Punto flotante de 16 bits, mitad del consumo de memoria.
• INT8: Entero de 8 bits, buen balance.
• INT4: Entero de 4 bits, muy compacto, posibles pérdidas de calidad.
• GGUF: Formato de llama.cpp, muy utilizado para inferencia local.
• AWQ: Activation-aware Weight Quantization, frecuentemente usado en GPUs NVIDIA.
• GPTQ: General-purpose Quantization, optimizado para GPUs.
• EXL2: Formato para exllamav2, permite bits variables.
• KV-Cache: Almacenamiento para cálculos intermedios, también cuantizable.

Niveles de cuantización comparados

Bits	Memoria	Calidad	Velocidad	Uso
32 bits	100%	Muy alta	Lenta	Entrenamiento, investigación
16 bits	50%	Alta	Media	GPUs con suficiente VRAM
8 bits	25%	Buena	Rápida	GPUs de consumidor
4 bits	12,5%	Aceptable a buena	Muy rápida	Hardware limitado
3 bits / 2 bits	Mínima	Media a baja	Muy rápida	Experimental

Formatos principales

GGUF

El formato más conocido para modelos locales. Soporta varios números de bits y funciona en CPU y GPU. Ideal para Ollama, llama.cpp y KoboldCpp.

Ejemplo:

llama-3.1-8b.Q4_K_M.gguf

• Q4: Cuantización de 4 bits.
• _K_M: Cuantización mixta con mayor precisión en pesos importantes.

GPTQ

Optimizado para GPU, reduce pesos específicamente para hardware NVIDIA. Funciona bien con vLLM y AutoGPTQ.

AWQ

Particularmente eficiente para inferencia rápida en GPUs NVIDIA.

EXL2

Permite bits variables y buena velocidad con exllamav2.

Cuantización con Ollama

Ollama proporciona muchos modelos ya cuantizados. También puedes cargar tus propios archivos GGUF:

ollama create mein-modell -f Modelfile

Un Modelfile simple:

FROM ./llama-3.1-8b.Q4_K_M.gguf

SYSTEM "Du bist ein hilfreicher Assistent."

Herramientas para cuantizar

• llama.cpp: Conversión y cuantización a GGUF.
• AutoGPTQ: Cuantización GPTQ.
• AutoAWQ: Cuantización AWQ.
• exllamav2: Cuantización EXL2.
• Ollama: Utiliza modelos ya cuantizados.
• LM Studio: Carga y gestiona modelos cuantizados.

Calidad versus velocidad

La opción correcta depende del hardware y la aplicación:

• Modelos de 7B: En hardware de consumidor, típicamente 4 bits u 8 bits.
• Modelos de 13B: 4 bits con Q4_K_M o Q4_K_S.
• Modelos de 70B: Múltiples GPUs o CPU muy potente, generalmente 4 bits.
• Codificación y razonamiento: Prefiere bits más altos, la precisión es crítica.
• Aplicaciones de chat simples: 4 bits frecuentemente es suficiente.

Errores comunes

• Cuantización excesiva: Los modelos de 2 bits pierden mucha calidad.
• Formato incorrecto: Usar GGUF en GPU o GPTQ en CPU puede ser ineficiente.
• Ignorar KV-Cache: Contextos grandes requieren mucha memoria.
• Enfocarse solo en tamaño de archivo: Q4_K_M y Q4_0 difieren en calidad.
• No probar: Siempre experimenta con tus propios prompts.

Enlaces y referencias adicionales

• BotServ.de Calculadora de cuantización
• BotServ.de Ejecutar LLM localmente
• BotServ.de Requisitos de RAM y VRAM

Preguntas frecuentes: Cuantización

¿Pierdo mucha calidad con 4 bits? Con métodos modernos como Q4_K_M, frecuentemente muy poco. Para aplicaciones críticas, debes probar.

¿Puedo cuantizar modelos yo mismo? Sí, usando llama.cpp, AutoGPTQ, AutoAWQ o exllamav2.

¿Qué es mejor: GGUF o GPTQ? GGUF es más versátil, GPTQ suele ser más rápido en GPUs NVIDIA.

¿Cuánta VRAM necesito? Aproximadamente el tamaño del modelo más el KV-Cache. Un modelo de 8B en 4 bits requiere alrededor de 6 a 8 GB de VRAM.

¿Puedo combinar técnicas de cuantización? Sí, por ejemplo pesos de 4 bits con activaciones de 8 bits.

Fuentes y lecturas adicionales

• llama.cpp: https://github.com/ggerganov/llama.cpp
• Modelos GGUF de TheBloke: https://huggingface.co/TheBloke
• AutoAWQ: https://github.com/casper-hansen/AutoAWQ

Resumen: Fundamentos de la cuantización de modelos

La cuantización hace que grandes modelos de IA sean utilizables en hardware más limitado. Al reducir el número de bits, disminuyen los requisitos de memoria y carga computacional, mientras que con métodos adecuados la calidad generalmente se mantiene alta. Formatos como GGUF, GPTQ, AWQ y EXL2 ofrecen diferentes compromisos. Entender cuantización te permite elegir el nivel adecuado para tu configuración y aplicación.