DeepMind a Hugging Face: la migración que le ahorra $18K/mes

Tu modelo lleva tres meses en Google DeepMind, y el dashboard refleja $22,000 mensuales. Tu CTO te envía un Slack urgente: "Necesitamos reducir esta factura o cerramos la ronda sin runway suficiente". Siempre la misma conclusión: migrar a Hugging Face. Sin embargo, nadie en tu equipo ha trabajado con transformers fuera del ecosistema Google, el modelo depende de Vertex AI, y la documentación oficial es un PDF de 47 páginas que asume que sabes lo que estás haciendo.

Photo: Igor Omilaev on Unsplash

Este tutorial es la ruta completa que armé tras migrar cuatro modelos de producción de DeepMind a Hugging Face en 2025, reduciendo costos operativos en un impresionante 73% y eliminando el vendor lock-in de Google Cloud. Esto no es teoría: es la arquitectura exacta, los comandos precisos y las decisiones técnicas que tomé cuando mi CFO me dio tres semanas para reducir la factura o despedir a dos ingenieros.

Por qué DeepMind te cobra más por lo mismo que Hugging Face da gratis

Google DeepMind ofrece infraestructura de primer nivel, pero pagas por tener el privilegio de usarla, incluso cuando el modelo no está en acción. Hugging Face opera de manera distinta: solo pagas por el tiempo de computación activa, el almacenamiento de modelos es gratuito hasta 100GB, y puedes escalar desde una instancia T4 hasta clusters A100 sin cambiar una línea de código.

Lo curioso es que la diferencia real está en la facturación. En DeepMind, mantienes endpoints activos 24/7 porque reiniciar un modelo de 7B parámetros puede llevar de 4 a 8 minutos. Esto te cuesta $0.85/hora por una instancia n1-standard-8 con GPU T4, incluso en horas de bajo tráfico. En cambio, Hugging Face Inference Endpoints te cobra por cada segundo de computación activa, y el cold start de un modelo optimizado con ONNX Runtime se reduce a unos 12 segundos.

Hice las cuentas con nuestro modelo de clasificación multimodal que maneja 340,000 requests mensuales: DeepMind nos cobraba $22,400/mes manteniendo dos réplicas activas para alta disponibilidad. Hugging Face, con un autoscaling bien configurado, nos costó $4,100/mes durante los primeros 60 días, procesando el mismo volumen con una latencia p95 inferior (280ms vs 340ms). Honestamente, los números hablan por sí solos.

Exportando tu modelo desde Vertex AI sin romper dependencias críticas

Photo: Luke Jones on Unsplash

El primer reto técnico es que tu modelo en DeepMind probablemente tiene dependencias hardcodeadas al SDK de Google. Si usaste google.cloud.aiplatform para cargar datos durante el entrenamiento o vertexai.preview.language_models para el fine-tuning, necesitas reescribir esas capas antes de exportar.

Comienza por identificar todas las importaciones de Google en tu código:

# Busca todas las dependencias de Google en tu proyecto
grep -r "from google" --include="*.py" | grep -v "__pycache__"
grep -r "import google" --include="*.py" | grep -v "__pycache__"

La mayoría de los modelos en DeepMind están serializados en formato SavedModel de TensorFlow o en checkpoints de PyTorch con rutas absolutas a Google Cloud Storage. Para exportar correctamente, debes convertir tu modelo a un formato compatible con Hugging Face Hub.

Si tu modelo es TensorFlow/Keras:

import tensorflow as tf
from transformers import TFAutoModelForSequenceClassification

# Carga tu modelo desde DeepMind
model = tf.keras.models.load_model('gs://your-bucket/model-checkpoint')

# Convierte a formato Transformers si es arquitectura compatible
hf_model = TFAutoModelForSequenceClassification.from_pretrained(
    'google/bert-base-uncased',
    num_labels=model.output_shape[-1]
)

# Transfiere los pesos manualmente
for layer_name in model.layers:
    if hasattr(hf_model, layer_name.name):
        hf_model.get_layer(layer_name.name).set_weights(
            model.get_layer(layer_name.name).get_weights()
        )

# Guarda en formato Hugging Face
hf_model.save_pretrained('./exported-model')

Si tu modelo es PyTorch, una opción más común en los modelos modernos:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

# Descarga el checkpoint desde GCS
!gsutil -m cp -r gs://your-bucket/pytorch-checkpoint ./local-checkpoint

# Carga el modelo
model = torch.load('./local-checkpoint/model.pt', map_location='cpu')

# Si usaste arquitectura custom, necesitas envolver en AutoModel
base_model = AutoModelForCausalLM.from_pretrained('gpt2')
base_model.load_state_dict(model.state_dict(), strict=False)

# Exporta el modelo
base_model.save_pretrained('./hf-ready-model')

El problema más común que enfrenté durante las migraciones fue que los tokenizers estaban hardcodeados con vocabularios custom en Cloud Storage. Hugging Face necesita el tokenizer en formato local:

from transformers import AutoTokenizer

# Si tu tokenizer está en GCS
!gsutil cp gs://your-bucket/tokenizer.json ./

# Carga y convierte
tokenizer = AutoTokenizer.from_pretrained(
    './local-checkpoint',
    tokenizer_file='./tokenizer.json'
)

# Guarda en formato Hugging Face
tokenizer.save_pretrained('./hf-ready-model')

Subiendo tu modelo a Hugging Face Hub sin arruinar el control de versiones

Una vez que tienes el modelo exportado en un formato compatible, subirlo a Hugging Face Hub es sencillo, pero hay trampas. La mayor: si tu modelo pesa más de 5GB y usas git lfs sin una correcta configuración, podrías esperar horas frente a un progress bar mientras la conexión falla repetidamente.

Instala las dependencias necesarias:

pip install huggingface_hub[cli]
git lfs install
huggingface-cli login

El login requiere un token de acceso que generas en huggingface.co/settings/tokens. Importante: necesitas un token con permisos de escritura, no el de solo lectura.

Crea el repositorio desde CLI:

huggingface-cli repo create your-model-name --type model --private

El flag --private es clave si tu modelo incluye fine-tuning sobre datos propietarios. Puedes hacerlo público después, pero no puedes revertir un repo público a privado.

Para modelos pequeños (menos de 5GB), sube directamente:

cd ./hf-ready-model
git init
git lfs track "*.bin" "*.safetensors" "*.h5"
git add .
git commit -m "Initial model upload from DeepMind migration"
git remote add origin https://huggingface.co/your-username/your-model-name
git push origin main

Para modelos grandes, usa el método programático que maneja reintentos automáticos:

from huggingface_hub import HfApi

api = HfApi()

api.upload_folder(
    folder_path="./hf-ready-model",
    repo_id="your-username/your-model-name",
    repo_type="model",
    commit_message="Migrated from Google DeepMind",
    multi_commits=True,  
    multi_commits_verbose=True
)

El parámetro multi_commits=True divide la subida en bloques de 500MB, lo que previene timeouts y permite reanudar si falla. Nuestro modelo de 14GB tardó 38 minutos en subir con esta configuración, en comparación con las 6 horas que tomó el primer intento con git push directo. En mi experiencia, este detalle hace toda la diferencia.

Configurando Inference Endpoints con autoscaling real

Hugging Face Inference Endpoints es donde recuperas los $18K mensuales que gastabas en DeepMind. Pero, ojo, la configuración por defecto puede ser costosa e ineficiente: ya sea instancias pequeñas que fallan bajo carga o grandes que funcionen vacías durante horas.

En el dashboard de Hugging Face, ve a tu modelo y selecciona "Deploy" → "Inference Endpoints". Ignora la recomendación automática de hardware y configura manualmente:

Para modelos de hasta 7B parámetros con tráfico variable:

• Instance: 1x NVIDIA T4 (16GB VRAM)
• Framework: pytorch con transformers
• Min replicas: 0
• Max replicas: 3
• Scale-up threshold: 70% GPU utilization
• Scale-down delay: 300 seconds

Para modelos de 13B+ parámetros:

• Instance: 1x NVIDIA A10G (24GB VRAM)
• Quantization: bitsandbytes 8-bit si aceptas 3% de degradación en accuracy
• Min replicas: 0
• Max replicas: 2

La configuración min replicas=0 asegura que tu endpoint se apague completamente sin tráfico. El primer request tras un cold start lleva de 8 a 15 segundos, pero si tu aplicación puede tolerar esa latencia ocasional, te ahorras entre un 65% y un 80% comparado con mantener instancias en warm 24/7.

Configura el autoscaling desde el código:

from huggingface_hub import HfApi

api = HfApi(token="your-write-token")

endpoint = api.create_inference_endpoint(
    name="your-model-production",
    repository="your-username/your-model-name",
    framework="pytorch",
    task="text-generation",
    accelerator="gpu",
    instance_size="x1",
    instance_type="nvidia-t4",
    min_replica=0,
    max_replica=3,
    scale_to_zero_timeout=300,
    type="protected" 
)

El parámetro scale_to_zero_timeout=300 define cuántos segundos sin requests debe esperar antes de escalar a cero. Si tu tráfico tiene picos regulares cada 10 minutos, sube este valor a 600 para evitar constantes cold starts.

Migrando requests de producción sin downtime ni doble facturación

La parte más delicada de cualquier migración es el cutover: el momento en que rediriges el tráfico real de DeepMind a Hugging Face sin caídas ni errores 500 que arruinen la experiencia del usuario. La estrategia que funcionó en cuatro migraciones diferentes fue un blue-green deployment progresivo con feature flags.

Para comenzar, mantén ambos endpoints activos temporalmente. Es cierto, vas a pagar doble durante 2-3 semanas, pero es más barato que un incidente que afecte a los clientes:

import os
import requests
from typing import Dict, Any

DEEPMIND_ENDPOINT = os.getenv("DEEPMIND_API_URL")
HUGGINGFACE_ENDPOINT = os.getenv("HF_INFERENCE_URL")
HF_TOKEN = os.getenv("HF_API_TOKEN")

def get_model_prediction(text: str, use_hf: bool = False) -> Dict[str, Any]:
    if use_hf:
        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
        response = requests.post(
            HUGGINGFACE_ENDPOINT,
            headers=headers,
            json={"inputs": text}
        )
    else:
        headers = {"Authorization": f"Bearer {DEEPMIND_TOKEN}"}
        response = requests.post(
            DEEPMIND_ENDPOINT,
            headers=headers,
            json={"instances": [{"content": text}]}
        )
    
    return response.json()

Implementa un sistema de feature flags con porcentaje de rollout progresivo:

import random

def should_use_huggingface(user_id: str, rollout_percentage: int) -> bool:
    user_hash = hash(user_id) % 100
    return user_hash < rollout_percentage

# En tu código de producción
prediction = get_model_prediction(
    text=user_input,
    use_hf=should_use_huggingface(user.id, rollout_percentage=10)
)

Comienza con 5% de tráfico en Hugging Face, monitorea latencia y error rate durante 48 horas, y aumenta progresivamente: 10%, 25%, 50%, hasta llegar al 100%. Si surgen problemas, puedes hacer rollback inmediatamente ajustando el porcentaje a cero.

Alcanzado el 100% en Hugging Face, mantén el endpoint de DeepMind activo otros 7 días antes de apagarlo. Este safety net te ayudará en caso de descubrir un edge case no detectado en testing.

La factura real después de 90 días corriendo en Hugging Face

Tres meses después de migrar nuestro modelo principal de clasificación multimodal de DeepMind a Hugging Face, estos fueron los números reales:

DeepMind (antes de migración):

• Compute: $18,200/mes (2x n1-standard-8 + T4, 24/7)
• Storage: $340/mes (checkpoints en GCS)
• Network egress: $2,800/mes (transferencia a servicios externos)
• Monitoring: $1,100/mes (Cloud Logging + Monitoring)
• Total: $22,440/mes

Hugging Face (después de migración):

• Inference Endpoints: $3,800/mes (autoscaling 0-3 réplicas T4)
• Storage: $0 (modelo < 100GB en Hub gratuito)
• Bandwidth: $280/mes (inferencia serverless)
• Monitoring: $0 (logs básicos incluidos)
• Total: $4,080/mes

La reducción del 82% en costos operativos nos proporcionó un runway adicional de 11 meses al mismo ritmo de gasto. Pero el mayor beneficio no fue financiero: eliminamos el vendor lock-in que nos mantenía atados a Google Cloud, y ahora podemos mover workloads entre Hugging Face, Replicate o incluso infraestructura on-premise sin reescribir código.

La latencia mejoró de 340ms p95 en DeepMind a 280ms en Hugging Face, gracias a la eliminación del overhead de autenticación y serialización custom que Google añade a cada request. Y el cold start, que temíamos que fuera un problema, afectó a menos del 0.3% de los requests totales, ya que nuestro tráfico es lo suficientemente consistente para mantener al menos una réplica warm durante el horario laboral.

¿Vale la pena migrar si tu modelo ya funciona en DeepMind?

La pregunta no es si tu modelo funciona, sino cuánto te está costando este funcionamiento y qué alternativas existen. Si estás gastando más de $8,000 mensuales en inferencia y tu modelo no depende de capacidades exclusivas de Google (como TPU pods o integración directa con servicios de GCP), migrar a Hugging Face te devuelve el control operativo y te permite ahorrar entre un 60% y un 85% en costos recurrentes.

La migración técnica lleva de 3 a 14 días, dependiendo de la complejidad del modelo y las dependencias personalizadas. El cutover con feature flags añade otra semana de testing. Pero el retorno de inversión es inmediato: recuperas el equivalente a dos salarios junior de ingeniero cada trimestre, solo con la reducción de la factura cloud.

¿Tu modelo sigue en DeepMind porque nadie ha tenido tiempo para evaluar alternativas, o realmente aprovecha capacidades que solo Google puede ofrecer? En mi experiencia, es una pregunta que vale la pena hacerse.