Cuantización GGUF vs EXL2 vs AWQ: Comparativa Técnica de Formatos de Inferencia Local en 2026

1. La Necesidad de Cuantizar: El Cuello de Botella de Ancho de Banda de Memoria (Memory Bandwidth)

Existe una concepción errónea generalizada según la cual los modelos de lenguaje en inferencia están limitados por la capacidad de cálculo bruto (TFLOPS) de las tarjetas gráficas. En la fase de generación autoregresiva token a token (la fase de decodificación o decode phase), el factor limitante absoluto es el Memory Bandwidth (ancho de banda de memoria VRAM), no la velocidad de cómputo del silicio.

Para generar un único token, la GPU debe leer la totalidad de los parámetros del modelo desde la memoria HBM/GDDR hacia los registros de cómputo de los Streaming Multiprocessors (SMs). Si tienes un modelo de 7B parámetros en precisión de 16 bits (14 GB):

• En una NVIDIA RTX 4090 con 1.008 GB/s de ancho de banda, la velocidad teórica máxima de lectura es de aproximadamente 1008 / 14 ≈ 72 tokens/segundo.
• Si cuantizas ese mismo modelo a 4 bits (3.5 GB de peso total), la GPU solo necesita transferir 3.5 GB por cada token generado: 1008 / 3.5 ≈ 288 tokens/segundo teóricos.

La cuantización no solo permite que modelos gigantescos quepan en tarjetas de consumo económico, sino que multiplica de forma directa la velocidad de generación al reducir los bytes físicos transferidos por ciclo.

2. Formato GGUF: El Estándar Universal de llama.cpp y Ollama

Desarrollado por Georgi Gerganov y la comunidad de código abierto de llama.cpp como sucesor de los antiguos formatos GGML y GGJT, GGUF (GPT-Generated Unified Format) es un formato de archivo binario autocontenido y extensible diseñado para almacenar tanto los pesos del modelo como la totalidad de sus hiperparámetros, tokenizador, plantilla de chat (chat template) y metadatos de arquitectura en un único archivo .gguf.

Características Técnicas Clave de GGUF

1. Mapeo de memoria ultraeficiente (mmap): GGUF permite que el sistema operativo mapee directamente el archivo del disco en el espacio de memoria virtual sin requerir deserializaciones complejas ni pasos de copiado intermedios, logrando tiempos de carga instantáneos.
2. Offloading Flexible por Capas: Puedes enviar, por ejemplo, 22 capas a los 8 GB de VRAM de tu tarjeta gráfica y mantener las 10 capas restantes en la memoria RAM del sistema procesadas por la CPU. El runtime gestiona la sincronización sin que el proceso colapse.
3. Variedad de K-quants (Q4_K_M, Q5_K_S, Q8_0): GGUF introdujo esquemas de cuantización avanzados (denominados K-quants) que cuantizan diferentes bloques de pesos con precisiones heterogéneas. Por ejemplo, el popular Q4_K_M utiliza 4 bits para los pesos de atención estándar, pero mantiene 6 bits para capas críticas de feed-forward, minimizando la pérdida de perplejidad.

3. Formato EXL2: El Rey de la Velocidad Pura en GPUs NVIDIA

Creado por el desarrollador turboderp dentro de la biblioteca ExLlamaV2, el formato EXL2 fue diseñado desde el primer día con una meta intransigente: exprimir hasta el último ciclo de reloj de las tarjetas gráficas NVIDIA de arquitectura moderna (Turing, Ampere, Ada Lovelace, Blackwell).

¿Qué hace a EXL2 tan revolucionario?

A diferencia de la mayoría de esquemas de cuantización que fuerzan un valor entero de bits (2, 3, 4 u 8 bits por parámetro), EXL2 opera con bits por peso fraccionarios (fractional bpw). Mediante un proceso de optimización global, el cuantizador de EXL2 analiza la sensibilidad al error de cada matriz de proyección y subcapa del modelo:

# Ejemplo de cuantización EXL2 a 4.25 bits por peso
python convert.py -i /ruta/modelo-original-fp16/                   -o /ruta/trabajo/                   -cf /ruta/modelo-exl2-4.25bpw/                   -b 4.25

Si tienes una tarjeta RTX 4080 de 16 GB y deseas correr un modelo de 14B que en 5 bits ocupa 14.8 GB (dejando muy poco espacio para el KV Cache de contexto), puedes cuantizar el modelo a exactamente 4.25 bpw o 3.85 bpw, encajando a la perfección en tu presupuesto de VRAM sin sacrificar la precisión que se perdería al bajar forzosamente a 3 bits enteros.

4. Formato AWQ: La Elección Empresarial para Servidores de Producción

Publicado por investigadores del MIT, AWQ (Activation-aware Weight Quantization) parte de una premisa matemática fundamental: no todos los pesos de una red neuronal tienen la misma importancia funcional. Al examinar las activaciones que fluyen por la red durante la inferencia con texto real, los autores descubrieron que solo entre un 0.5% y un 1% de los canales de pesos son responsables de la mayor parte de la capacidad de razonamiento y coherencia sintáctica del modelo.

A diferencia de métodos más antiguos como GPTQ que intentaban compensar el error de cuantización mediante la matriz Hessiana de segundo orden (lo que en ocasiones provocaba sobreajuste o inestabilidades numéricas en secuencias largas), AWQ simplemente identifica los pesos sobresalientes y los protege escalando sus valores antes de la cuantización lineal de 4 bits.

¿Por qué AWQ domina en vLLM y TGI?

1. Kernels de Des-cuantización en Tiempo Real: AWQ implementa kernels CUDA especializados que desempacan los pesos de 4 bits directamente a los registros de cálculo en precisión FP16/BF16 en el momento exacto de la multiplicación de matrices (GEMM), sin necesidad de instanciar pesos FP16 en la memoria global de la GPU.
2. Integración con PagedAttention: A diferencia de los motores orientados a usuario individual, AWQ está profundamente integrado con los algoritmos de paginación de memoria de vLLM. Esto permite procesar docenas de solicitudes simultáneas en servidores web sin fragmentar el KV Cache.

# Servir un modelo AWQ con alta concurrencia en vLLM
from vllm import LLM, SamplingParams

llm = LLM(
    model="TheBloke/Llama-2-13B-chat-AWQ",
    quantization="awq",
    dtype="half",
    max_model_len=4096,
    gpu_memory_utilization=0.90
)

prompts = ["Explica el funcionamiento de AWQ en tres frases:"]
sampling_params = SamplingParams(temperature=0.7, top_p=0.9, max_tokens=150)
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(output.outputs[0].text)

5. Comparativa Práctica de Perplejidad y Pruebas de Razonamiento

La perplejidad (perplexity) es la métrica estándar que mide la incertidumbre de un modelo probabilístico de lenguaje al predecir el siguiente token de un texto de referencia (como el dataset WikiText-2). Cuanto menor sea la perplejidad, más fiel es el modelo a su versión original no comprimida (FP16):

• Modelo Base Llama 3 8B en FP16 nativo: Perplejidad de referencia ~6.14 en WikiText-2.
• GGUF Q8_0: Perplejidad ~6.15 (degradación matemáticamente imperceptible).
• AWQ 4-bit: Perplejidad ~6.32 (excelente retención de capacidades lógicas y código).
• EXL2 a 4.2 bpw: Perplejidad ~6.30 (calidad prácticamente indistinguible de AWQ con 30% más velocidad en mono-hilo).
• GGUF Q4_K_M: Perplejidad ~6.38 (muy sólida para la mayoría de tareas conversacionales).
• Cuantizaciones agresivas a 2 o 3 bits: La perplejidad se dispara por encima de 8.50, provocando alucinaciones sintácticas, bucles infinitos y degradación severa en tareas de razonamiento matemático.

6. Artículos Relacionados en The Calata para Complementar tu Stack

Continúa optimizando tu infraestructura técnica explorando nuestros contenidos recomendados:

• Aprende a desplegar servicios locales con la Guía Completa para Configurar Ollama en Servidores Linux con GPU.
• Compara motores de inferencia masiva en vLLM vs TGI para Despliegues de Alta Concurrencia.
• Si experimentas problemas de memoria en tus scripts de prueba, consulta Cómo Resolver Errores CUDA Out of Memory en PyTorch.
• Domina la reducción de latencia en la salida de tokens con Técnicas de Optimización de Latencia TTFT.