Cuantización en vLLM: FP8, INT4 y NVFP4 sin perder el plot

Tu checkpoint de 30B en FP8 no lo cuantizaste tú: lo descargaste de Hugging Face con el sufijo -FP8. Eso es lo correcto el 90% de las veces. La cuantización interesante empieza cuando el modelo que quieres no tiene checkpoint cuantizado, o cuando cabe justo en tu GPU y necesitas margen para la KV cache. Este capítulo cubre qué formato usar, cuándo bajar uno hecho y cuándo fabricar el tuyo con LLM Compressor.

El menú real, por hardware

Cuatro formatos dominan el serving con vLLM en 2026, y la tarjeta que tienes decide por ti:

NVFP4 es el formato que las gpu Blackwell ejecutan nativo, y todos los modelos grandes del año (DeepSeek V4, Kimi K3, Qwen3.8) publicaron checkpoints NVFP4 el mismo día. Si tu GPU no es Blackwell, ese sufijo en el nombre del checkpoint es solo letras. Fuente: anuncios de vLLM, octubre de 2026.

Primero busca, después cuantices

Antes de fabricar un checkpoint, revisa si Red Hat AI ya publicó el tuyo. Su pipeline con LLM Compressor produce checkpoints listos para vLLM constantemente: Qwen3.8-27B existe en INT4, NVFP4 y MXFP4; GLM-5.3 en NVFP4 y en formato mixto MXFP4xFP8 que baja el checkpoint de ~1507 GB a ~415 GB, un 72% menos, manteniendo el router y los embeddings en precisión original. Fuente: README de LLM Compressor.

La regla: checkpoint oficial cuantizado con evaluación publicada > cuantizar tú mismo con RTN a las 2 AM. Hazlo tú solo cuando el modelo es tu fine-tune o es demasiado nuevo para tener versión cuantizada.

Fabrica el tuyo: LLM Compressor en 15 líneas

# quantize.py
from transformers import AutoModelForCausalLM, AutoTokenizer
from llmcompressor import oneshot
from llmcompressor.modifiers.quantization import QuantizationModifier

MODEL_ID = "Qwen/Qwen3-30B-A3B"

model = AutoModelForCausalLM.from_pretrained(MODEL_ID)
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)

recipe = QuantizationModifier(
    targets="Linear",
    scheme="FP8_BLOCK",
    ignore=["lm_head", "re:.*mlp.gate$"],
)

oneshot(model=model, recipe=recipe)
model.save_pretrained("Qwen3-30B-A3B-FP8-BLOCK")
tokenizer.save_pretrained("Qwen3-30B-A3B-FP8-BLOCK")

Dos líneas de esa receta importan más que el resto. ignore excluye lm_head y el gate del MoE: cuantizar la capa de salida o el router es la forma más rápida de que tu modelo empiece a responder disparates. Y scheme="FP8_BLOCK" es FP8 por bloques de 128, el formato que vLLM carga directo. Nota que el ejemplo usa el algoritmo más simple (round-to-nearest); para recuperar más calidad existe GPTQ con calibración, a costa de un oneshot más lento. Fuente: guía de LLM Compressor.

Para modelos que no caben en tu GPU ni comprimidos, LLM Compressor soporta offload a disco y procesamiento capa por capa: el checkpoint de 400 GB se cuantiza en una máquina con 64 GB de RAM, solo más despacio.

La KV cache: la otra mitad de la cuenta

Cuantizar pesos es la mitad del pastel de VRAM; la otra mitad ya la manejas con --kv-cache-dtype fp8 del capítulo 5: 96 KB por token en FP16 pasan a 48 KB, el doble de contexto en la misma tarjeta.

¿Y bajar más, a 4 bits? vLLM publicó un estudio de TurboQuant en mayo de 2026 comparando KV cache en 4 bits contra FP8 en workloads largos: los casos donde 4 bits ayuda existen, pero la conclusión fue que FP8 sigue siendo el default — el ahorro extra de memoria no compensa el riesgo de calidad en la mayoría de workloads. Fuente: blog de vLLM. Mismo consejo para la atención en FP8: vLLM validó en Hopper y Blackwell que conviene saltarse algunas capas, y el flag ya lo hace por ti.

Verifica que no perdiste el plot

La verificación honesta se hace con tus prompts: 20 entradas reales de tu workload contra el modelo en BF16 y contra el cuantizado, comparadas lado a lado. En el estudio de LLM Compressor y en los model cards de RedHatAI, FP8 W8A8 típicamente se queda por debajo de un punto de perdida en benchmarks estándar; INT4 puede caer más en tareas de código y matemática. Si tu suite de 20 prompts pasa, el checkpoint va a producción. Si no, sube a FP8 o prueba GPTQ con calibración antes de culpar a la cuantización.

Checkpoint y el error típico

Checkpoint: sabes qué formato pide tu GPU antes de buscar checkpoint, y tienes una suite de 20 prompts para validar cualquier cuantización antes de servir.

El error típico: cuantizar sin lista ignore. El lm_head y los gates del MoE en 4 bits producen salidas roto de forma determinista: el modelo responde fluido durante 200 tokens y luego desvaría. Siempre excluye esas capas, y si descargas un checkpoint comunitario, mira que su config de cuantización las excluya también.

Siguiente capítulo

Tu modelo cabe y habla JSON. Ahora lo aceleramos: speculative decoding, la técnica que baja tu TPOT sin tocar el hardware.