Vertex AI quizás esté cobrándote por recursos que no necesitas. En diciembre de 2025, tres startups europeas descubrieron que sus modelos en producción utilizaban 4,3 veces más recursos de los necesarios. Esto no se debía a que los modelos fueran ineficientes, sino a la configuración por defecto de Google Cloud, que prioriza la conveniencia por encima del costo. ¿El resultado? Una factura mensual promedio alrededor de $12.400, de la cual el 71% era evitable con ajustes arquitectónicos que Google Cloud no documenta exhaustivamente.
Aquí desglosamos un método para reducir costos operativos en Vertex AI sin perder rendimiento. No es cuestión de cambiar de proveedor o comprometer la calidad de inferencia. Se trata de comprender qué te cobra Google, detectar las fugas silenciosas y rediseñar tu pipeline de ML para optimizar costos por predicción. Las decisiones arquitectónicas que siguen han sido probadas en producción y transformarán tu estructura de costos.
El problema real está en la configuración por defecto, no en el modelo
Vertex AI ofrece tres modos de deployment: endpoints dedicados, batch prediction y AutoML. La documentación oficial propone endpoints dedicados como la ruta estándar para modelos en producción. Sin embargo, lo que no te dicen es que estos endpoints mantienen instancias compute activas 24/7, incluso sin tráfico.
Por ejemplo, una fintech española observó que su modelo de detección de fraude procesaba el 83% de las transacciones entre 9 AM y 6 PM. Fuera de ese horario, el endpoint seguía consumiendo $340 diarios en instancias n1-standard-4. El costo mensual de instancias inactivas superaba los $10.200. La solución fue migrar a batch prediction para cargas no críticas y usar Cloud Run con contenedores personalizados para inferencia bajo demanda.
Cómo medir el idle real de tu endpoint
Antes de rediseñar, necesitas visibilidad. Google Cloud Monitoring ofrece métricas de utilización, pero no muestra cuántas horas tu endpoint está activo sin recibir requests. Implementa esta consulta en Cloud Logging:
resource.type="ml_job"
resource.labels.job_id="[TU_ENDPOINT_ID]"
jsonPayload.prediction_count=0
Agrupa por ventanas de 1 hora durante 7 días. Si más del 30% de las ventanas reportan cero predicciones, tienes un problema arquitectónico, no de modelo. La solución puede ser apagar instancias durante baja demanda o migrar a inferencia serverless.
Batch prediction reduce costos en 62% para cargas no real-time
Batch prediction es la funcionalidad menos promocionada de Vertex AI, pero la más rentable para usos que toleran latencias de minutos. En lugar de mantener un endpoint activo, envías un archivo con inputs al servicio de batch, Google provisiona recursos bajo demanda, procesa y destruye las instancias.
El costo de batch prediction es aproximadamente un 38% del costo de un endpoint dedicado para el mismo volumen de predicciones. Como ejemplo, una startup de e-commerce que procesaba 4 millones de predicciones al mes vio su factura reducirse de $8.900 a $3.380 al migrar recomendaciones de producto a batch nocturno.
Casos donde batch no funciona
Batch prediction introduce latencia. Si tu producto requiere inferencia en menos de 500ms, batch no es viable. ¿Pero acaso todos los casos en tu aplicación necesitan latencia sub-segundo? Segmenta:
- Real-time crítico: autenticación, detección de fraude en transacciones live. Endpoint dedicado es inevitable.
- Near real-time: recomendaciones, moderación de contenido no urgente. Cloud Run con contenedores es más adecuado.
- Batch tolerante: analítica predictiva, generación de reportes. Ideal para batch prediction.
En una auditoría de 2026 sobre startups usando Vertex AI, solo el 23% de los modelos realmente necesitaban latencia real-time. El 77% restante pagaba por infraestructura innecesaria.
La optimización de instancias que Google no configura por ti
Los endpoints dedicados de Vertex AI corren sobre Compute Engine. Por defecto, Google usa instancias n1-standard-4 (4 vCPUs, 15GB RAM) incluso para modelos pequeños. Un modelo BERT para clasificación de texto puede funcionar bien en una n1-standard-2, reduciendo el costo en un 50%.
Sin embargo, cambiar el tipo de instancia requiere eliminar el endpoint y redesplegarlo con configuración custom, probando que el rendimiento no se degrade. Google no ofrece auto-scaling vertical, solo horizontal. Esto implica que si el tráfico crece, el sistema añade más instancias del mismo tamaño, no instancias más grandes.
Rightsizing: el proceso completo
-
Perfilar consumo real de recursos: utiliza Cloud Profiler para capturar uso de CPU y memoria durante una semana.
-
Identificar el percentil 95: optimiza para el percentil 95 de uso de CPU, no para el pico máximo.
-
Testear en staging con instancias menores: crea un endpoint paralelo y mide latencia replicando el 10% del tráfico de producción.
-
Migrar gradualmente: cambia el endpoint de producción solo si la latencia en staging es aceptable.
Una insurtech alemana descubrió que sus endpoints estaban sobredimensionados. Al migrar de n1-standard-4 a e2-standard-2, redujeron costos de $14.200 a $6.100, con un ligero aumento en latencia P95 de 180ms a 195ms, totalmente aceptable.
Model distillation: la estrategia que cambia la ecuación de costos
Para modelos grandes (más de 500M parámetros), el costo de inferencia se debe más al tiempo de compute que a las instancias. Un modelo GPT-2 medium puede procesar 12 predicciones por segundo en una n1-standard-4. Un modelo distilled del mismo accuracy puede procesar 48 predicciones por segundo en la misma instancia.
Distillation entrena un modelo pequeño (el "estudiante") para replicar el comportamiento de un modelo grande (el "maestro"). Aunque no alcanza la precisión absoluta del maestro, puede lograr un 97-99% de performance con 1/4 del tamaño. Esto se traduce en un throughput 4x superior y costos 75% menores.
Implementación práctica en TensorFlow
Google no ofrece distillation como servicio managed en Vertex AI. Debes implementarlo manualmente.
import tensorflow as tf
from tensorflow import keras
teacher_model = keras.models.load_model('gs://tu-bucket/teacher_model')
student_model = keras.Sequential([
keras.layers.Dense(128, activation='relu', input_shape=(768,)),
keras.layers.Dropout(0.2),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
def distillation_loss(y_true, y_pred, teacher_pred, temperature=3.0, alpha=0.7):
soft_labels = tf.nn.softmax(teacher_pred / temperature)
distill_loss = tf.keras.losses.KLDivergence()(soft_labels, y_pred / temperature)
student_loss = tf.keras.losses.categorical_crossentropy(y_true, y_pred)
return alpha * distill_loss + (1 - alpha) * student_loss
for epoch in range(10):
for batch in dataset:
x, y = batch
teacher_pred = teacher_model(x, training=False)
with tf.GradientTape() as tape:
student_pred = student_model(x, training=True)
loss = distillation_loss(y, student_pred, teacher_pred)
gradients = tape.gradient(loss, student_model.trainable_variables)
optimizer.apply_gradients(zip(gradients, student_model.trainable_variables))
El parámetro temperature controla qué tanto "suavizar" las predicciones del maestro. Valores entre 2 y 5 son efectivos. El alpha balancea entre aprender del maestro y de los labels reales. Comienza con 0.7 y ajusta según la validación.
Una startup de NLP española realizó distillation en un modelo BERT para clasificación de tickets de soporte. El modelo original procesaba 8 requests/segundo, y después de la distillation, procesaba 34 requests/segundo con solo un 2% de caída en F1 score. El costo de inferencia cayó de $6.700 a $1.900.
Auto-scaling: cuando la configuración manual te cuesta más que el modelo
El auto-scaling de Vertex AI tiene dos parámetros: mínimo y máximo de réplicas. Por defecto, min=1 y max=10. Si el tráfico cae a cero, sigues pagando por esa instancia mínima.
Configura min=0 para endpoints no críticos. Vertex AI tomará 3-5 minutos en provisionar una instancia cuando haya un request tras un periodo inactivo. Esto no es viable para servicios de usuario, pero sí para:
- APIs internas de análisis
- Modelos de scoring batch
- Servicios de pre-procesamiento
Cold start mitigation con Cloud Run
Si necesitas latencia sub-segundo pero tráfico irregular, Cloud Run supera a Vertex AI endpoints. Empaqueta tu modelo en un contenedor Docker, expónlo vía Flask o FastAPI, y despliega a Cloud Run con min-instances=0, max-instances=100.
El cold start de Cloud Run varía entre 800ms y 2s. Para modelos pequeños (menos de 500MB), reduce el cold start a menos de 1 segundo con estas optimizaciones:
FROM python:3.11-slim
RUN pip install --no-cache-dir tensorflow==2.15.0 flask==3.0.0 gunicorn==21.2.0
COPY model /app/model
ENV PYTHONUNBUFFERED=1
CMD exec gunicorn --bind :$PORT --workers 1 --threads 4 --timeout 0 --preload app:app
El flag --preload carga el modelo antes de aceptar tráfico, convirtiendo el cold start en warm start. Una healthtech británica redujo la latencia P99 de cold start de 3.2s a 1.1s.
Caching de predicciones: la optimización que nadie implementa
Si tu modelo procesa inputs repetitivos, podrías estar desperdiciando recursos. Un modelo de clasificación de imágenes para moderación de contenido puede recibir la misma imagen de varios usuarios. Sin caching, procesas la misma imagen múltiples veces.
Implementa una capa de Redis antes del endpoint de Vertex AI. Hashea el input, consulta Redis y retorna el resultado cacheado si existe. Llama al modelo si no está en cache. Esto puede reducir costos en 40-60% dependiendo de la repetición.
Implementación en Python con Redis
import hashlib
import redis
import json
from google.cloud import aiplatform
redis_client = redis.Redis(host='tu-redis-host', port=6379, db=0)
CACHE_TTL = 3600
def predict_with_cache(input_data):
input_hash = hashlib.sha256(json.dumps(input_data, sort_keys=True).encode()).hexdigest()
cached_result = redis_client.get(input_hash)
if cached_result:
return json.loads(cached_result)
endpoint = aiplatform.Endpoint(endpoint_name='projects/123/locations/us-central1/endpoints/456')
prediction = endpoint.predict(instances=[input_data])
redis_client.setex(input_hash, CACHE_TTL, json.dumps(prediction.predictions[0]))
return prediction.predictions[0]
Define el TTL según el modelo. Para recomendaciones personalizadas, opta por TTL corto (5-15 minutos). Para clasificación de contenido estático, días o semanas son adecuados. Una plataforma de edtech implementó esto y descubrió que el 54% de las consultas a su modelo de corrección de ejercicios eran idénticas, reduciendo su factura de $9.100 a $4.200 mensuales.
La métrica que importa: costo por predicción, no costo absoluto
El error más común es obsesionarse con la factura total de Google Cloud. La métrica relevante es costo por predicción (CPP). Si tu factura mensual es $15.000 pero procesas 50 millones de predicciones, tu CPP es $0.0003. Reducir la factura a $8.000 pero solo procesar 20 millones eleva tu CPP a $0.0004. ¿Mejoraste realmente?
Rastrea CPP en Cloud Monitoring con métricas custom:
from google.cloud import monitoring_v3
import time
client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/ml/cost_per_prediction"
series.resource.type = "global"
point = monitoring_v3.Point()
point.value.double_value = total_cost / total_predictions
point.interval.end_time.seconds = int(time.time())
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])
Configura alertas cuando CPP supere tu umbral objetivo. Si tu target es $0.0005 por predicción y el CPP sube a $0.0007, investiga de inmediato. Las causas típicas incluyen tráfico bajo con instancias mínimas altas, auto-scaling mal configurado, modelos sobredimensionados, y falta de caching para inputs repetitivos.
¿Tu factura de Vertex AI está financiando ineficiencias arquitectónicas que creías inevitables? La mayoría de las startups que conozco asumen que el costo de IA es un impuesto fijo por hacer negocios en 2026. La realidad es que entre el 50% y el 70% del gasto en infraestructura de ML es evitable con decisiones arquitectónicas adecuadas. Google Cloud no optimizará tu factura; su incentivo es que consumas más, no menos. La optimización está en tus manos, y hacerla bien o mal puede determinar la viabilidad financiera de tu producto.