TGI de Hugging Face: servir modelos abiertos a escala

javi
Procesador chip de silicio en primer plano representando hardware de inferencia

Servir un LLM abierto en producción no es trivial. Mantener la GPU saturada, agrupar peticiones sin bloquear, aplicar cuantización sin perder calidad, exponer una API compatible con OpenAI: cada paso tiene complejidad. Text Generation Inference (TGI) de Hugging Face intenta resolver esa lista con una pila coherente. Es una de las opciones más maduras del ecosistema abierto. Cubrimos qué hace, cuándo es la elección correcta, y dónde otros proyectos lo superan.

Qué es TGI

TGI es un servidor de inferencia especializado en generación de texto. Escrito mayormente en Rust (el router) y Python (el worker con PyTorch). Soporta los modelos populares del hub: Llama 2, Mistral, Falcon, StarCoder, BLOOM, CodeLlama, Yi, MPT, Phi y variantes.

Las capacidades clave:

  • Continuous batching: agrupa peticiones concurrentes sin esperar a que la más lenta termine. Maximiza utilización de GPU.
  • FlashAttention v2: implementación optimizada de atención que reduce memoria y acelera.
  • PagedAttention: gestión de memoria KV-cache inspirada en vLLM (aunque vLLM lo hace mejor).
  • Tensor parallelism: partir el modelo entre varias GPUs.
  • Quantización: bitsandbytes, GPTQ, AWQ, EETQ. Inferencia 4-bit o 8-bit sin mayor trabajo.
  • Streaming: tokens al cliente en cuanto se generan (SSE).
  • Guided generation: gramáticas, regex, JSON schema via Outlines.
  • API compatible con OpenAI: /v1/chat/completions como capa adicional.

Despliegue mínimo

Desplegar TGI con Docker es directo:

docker run --gpus all --shm-size 1g -p 8080:80 \
  -v $PWD/data:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mistral-7B-Instruct-v0.2 \
  --quantize bitsandbytes-nf4

Tras unos minutos cargando, el endpoint responde a POST /generate con tokens en streaming. Para consumo tipo OpenAI, el flag --disable-custom-kernels y path /v1/chat/completions hacen el bridge.

En Kubernetes, el chart oficial text-generation-inference cubre despliegues con GPU operator. Pods necesitan nvidia.com/gpu: 1 (o más para tensor parallel).

Donde TGI brilla

Escenarios donde TGI es la opción correcta:

  • Modelos de Hugging Face Hub directos. Carga por ID, no conversión de formato.
  • Modelos cuantizados con bitsandbytes. TGI soporta NF4, FP4, INT8.
  • Streaming SSE de alta calidad. Primera-token-latency baja, throughput estable.
  • Endpoints Inferencia de Hugging Face. TGI es el motor detrás de su servicio gestionado.
  • Integración con Transformers. Misma familia de herramientas, compatibilidades probadas.

Si ya estás en el ecosistema HF, TGI es el camino menos fricción.

Donde otros lo superan

  • Throughput puro: vLLM en GPUs potentes exprime más tokens/segundo gracias a PagedAttention bien implementada.
  • CPU/Apple Silicon: llama.cpp es mejor para inferencia sin GPU.
  • Modelos esotéricos: TGI cubre los populares; modelos menos comunes o muy nuevos pueden no estar soportados.
  • Licencia: TGI 2.0+ cambió a una licencia comercial restrictiva para uso productivo. Hay que revisar términos; no siempre es “como era antes”.

Esta licencia merece atención — empresas que asumían código Apache están reevaluando. Algunas migran a vLLM puro por ello.

Optimizaciones gratis con TGI

Tres ajustes pequeños con gran impacto:

  • --max-batch-prefill-tokens: límite total de tokens en fase prefill (la pesada). Más alto = más concurrencia, más VRAM.
  • --max-total-tokens: ventana máxima por petición. Poner lo justo ahorra memoria.
  • --quantize gptq o --quantize awq: mejor que bitsandbytes si tienes un modelo GPTQ/AWQ pre-cuantizado.

Medir throughput antes/después con locust o vegeta es barato y evita suposiciones.

Cuantización sin perder calidad

Para Mistral-7B o Llama-7B, NF4 suele perder ~1-2% de calidad medido en benchmarks como MMLU. Para modelos más grandes (33B+), el impacto es menor. Para modelos pequeños (3B), cuantizar puede degradar más.

Recomendación: probar con tus propios casos de uso, no solo benchmarks públicos. Un modelo cuantizado que va bien en MMLU puede fallar en tu dominio específico.

API compatible con OpenAI

Muchas aplicaciones esperan /v1/chat/completions. TGI lo expone con:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tgi",
    "messages": [{"role": "user", "content": "Hola"}],
    "stream": true
  }'

Esto permite usar LangChain, LiteLLM, SDKs OpenAI, sin cambios de código. Una transición entre el modelo hosted y el self-hosted de minutos, no semanas.

Operación en producción

Checklist para operar TGI serio:

  • Health checks apuntando a /health.
  • Métricas Prometheus en /metrics — expone latencia, throughput, VRAM.
  • Limit concurrency a nivel router para evitar OOM en picos.
  • Backup del modelo descargado (si el hub está inaccesible, no puedes arrancar).
  • Monitoreo de temperatura GPU — GPUs a 90°C degradan y fallan.
  • Plan para updates de CUDA/driver — TGI es sensible a versiones.

Alternativas a tener en cuenta

  • vLLM: mejor throughput general, comunidad muy activa, Apache 2.0.
  • llama.cpp / Ollama: CPU y Apple Silicon; despliegue más simple.
  • TensorRT-LLM: el ceiling de rendimiento en GPUs NVIDIA, pero complejidad alta.
  • LMDeploy: alternativa china con muy buen rendimiento en ciertos modelos.

Conclusión

TGI ha sido la referencia de inferencia open-source de Hugging Face durante 2023 y sigue siéndolo para muchos casos: modelos populares del hub, cuantización fácil, API familiar, integración con el ecosistema HF. El cambio de licencia en 2.0 es importante de evaluar para usos comerciales. Para throughput absoluto en GPUs top, vLLM suele ganar; para simplicidad máxima en CPU, llama.cpp. TGI sigue siendo una elección robusta y sensata para la gran mayoría de equipos que sirven modelos abiertos.

Síguenos en jacar.es para más sobre servido de LLM, optimización GPU y pilas de inferencia.

Entradas relacionadas