Módulo final del Curso de GPU para IA. Tu servicio corre en la nube (Módulo 11); queda la pregunta que justifica —o no— todo el viaje: ¿sale a cuenta? Hoy: la aritmética del costo por token, la variable que casi todos ignoran, y el oficio de operar esto como adulto responsable.

La tesis del módulo

El costo de tu GPU no se mide por hora: se mide por millón de tokens útiles. Y entre ambas medidas hay una variable que lo decide todo — la utilización. Una GPU barata al 5% de uso es carísima; una cara al 90% puede ser una ganga.

La cuenta que cierra el curso

 costo por millón de tokens =

        precio de la GPU por hora
 ─────────────────────────────────────
  tokens útiles generados en esa hora

Ejemplo ilustrativo con números redondos (los tuyos saldrán de medir, no de copiar): una L4 a ~0,5 USD/hora sirviendo con vLLM y batching decente, digamos ~500 tokens/s sostenidos → 1,8 millones de tokens/hora → ~0,28 USD por millón de tokens. Contra una API comercial que cobra del orden de dólares por millón de tokens de salida, el propio parece ganar por paliza.

Parece. Esa cuenta asumió lo imposible: la GPU generando al máximo la hora completa.

La variable que decide: utilización

Si tu tráfico real solo mantiene la GPU ocupada el 10% del tiempo, tu costo real por token se multiplica por 10 — pagaste la hora entera y usaste seis minutos. La tabla de la verdad:

Utilización real	El millón de tokens te cuesta	Veredicto
~90% (saturada)	la cuenta ideal	El propio gana claro
~50%	el doble	Sigue ganando, con menos gloria
~10%	×10	La API era más barata
~1% (el side project)	×100	La API era MUY más barata

De aquí salen las tres reglas de decisión del curso completo:

Volumen alto y sostenido → GPU propia (pod saturado o serverless con tráfico denso). La economía manda.
Volumen bajo o errático → API comercial (o serverless puro con escala a cero). Pagar por token usado le gana a pagar por hora ociosa.
Lo difícil → frontier por API; lo masivo → tu GPU. El patrón híbrido del Módulo 9, ahora con sustento contable.

Y la honestidad final de la cuenta: al costo por hora súmale tu tiempo de operación. Un fin de semana tuyo depurando un deploy vale más que meses de diferencia de precio en tráfico bajo.

Operar: lo mínimo digno

Métricas. vLLM expone /metrics en formato Prometheus: throughput, peticiones en cola, uso de KV cache. A nivel GPU, nvidia-smi es la foto y las herramientas de NVIDIA para datacenter (DCGM) la película. Las tres señales que miran los que saben:

Utilización de GPU — la variable de la cuenta. Baja sostenida = arquitectura equivocada.
Latencia p95/p99 — no el promedio: los percentiles altos son los usuarios que sufren. Si p99 explota, el batching está saturado: toca escalar o acotar.
Cola de peticiones — el primer síntoma de que necesitas otra réplica, antes de que la latencia lo grite.

El checklist de producción, condensado del curso:

API key en todo endpoint; secretos en variables de entorno (M11)
--max-model-len acotado: el contexto es VRAM y la VRAM es dinero (M7)
Margen anti-OOM del 15–20% respetado (M2)
Pesos en volumen persistente, no re-descargados (M11)
Fallback a una API comercial si tu servicio cae: degradar es mejor que morir
Límites de uso por cliente: sin rate limit, un bucle ajeno te vacía la GPU
Alerta de facturación en el proveedor: la sorpresa de fin de mes no es un rito obligatorio

El mapa final del curso

 bloque básico        bloque intermedio    bloque avanzado
 el hardware          correrlo en local    llevarlo al mundo
 ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
 │ GPU y tipos  │     │ Ollama       │     │ arquitectura │
 │ VRAM y BW    │ ──► │ llama.cpp    │ ──► │ nube: mapa   │
 │ CUDA y stack │     │ vLLM         │     │ despliegue   │
 │ cuantización │     │ multi-tarea  │     │ costos       │
 └──────────────┘     └──────────────┘     └──────────────┘

La progresión completa: entiendes el fierro, lo haces trabajar en tu escritorio, y lo despliegas donde el mundo lo use — con la cuenta clara de cuándo conviene cada cosa. Ese era el contrato del módulo 1, y está cumplido.

Errores comunes

Decidir propio-vs-API con la cuenta ideal. Mide tu utilización real un mes; la tabla de arriba hace el resto.
Monitorear el promedio de latencia. El promedio esconde a los que esperan; p95/p99 o nada.
Operar sin fallback. Tu pod caído a las 3 AM con la API de respaldo configurada es una anécdota; sin ella, es una crisis.
Optimizar el costo por hora antes que la utilización. Regatear centavos de tarifa con la GPU al 10% es ordenar las sillas del Titanic.

La frase para llevarse

“La nube te vende horas; tus usuarios te piden tokens. El arquitecto es el que sabe a cuánto le está saliendo la conversión — y cuándo la respuesta correcta es no tener GPU.”

Qué viene: fin del curso

Doce módulos: del “¿qué es una GPU?” al costo por millón de tokens de tu propio servicio desplegado. Si completaste la serie con tu cuenta de la academia, el certificado es tuyo. El glosario de GPU queda como referencia permanente — y esta infraestructura es exactamente la que tus agentes necesitan para correr en serio.

GPU para IA — Módulo 12: producción, costos y decisiones