Deploy de Modelos DL en Producción: Guía Práctica con Flask y Docker

FilmScore

Hace tiempo que vengo dando vueltas al tema del despliegue de modelos de deep learning. Tengo un par de modelos entrenados con PyTorch (clasificación de imágenes y un pequeño transformer) y quiero pasarlos a producción. He visto opciones como TorchServe, FastAPI, o incluso TensorFlow Serving, pero me gustaría algo más DIY para entender el proceso a fondo. ¿Alguien ha armado una guía paso a paso que compile buenas prácticas? Me interesa especialmente: 1) serialización del modelo (TorchScript vs pickle), 2) API REST con Flask, 3) dockerización, y 4) escalado simple con Gunicorn. Si tienen ejemplos de código, mejor.

Calligraphy

Buena iniciativa. Te recomiendo empezar con TorchScript para serializar, evita pickle porque puede ser inseguro y rompe compatibilidad. Flask está bien para empezar, pero si quieres rendimiento, usa FastAPI con async. Docker ya es obligatorio. Aquí un esqueleto de Dockerfile que uso:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"]

Para escalar, mete un nginx reverso y listo.

Punk

Cuidado con meter nginx si es un proyecto pequeño. A veces con Gunicorn + Flask (o FastAPI) basta. Yo he desplegado modelos con TensorFlow Serving y es muy sólido, pero para PyTorch, TorchServe es la opción oficial. ¿Has probado a exportar a ONNX? Así te independizas del framework y puedes usar ONNX Runtime que es más eficiente.

FilmScore

Gracias por los tips. Lo de ONNX suena bien, pero quiero mantener todo en PyTorch para no añadir dependencias. Lo de FastAPI lo he visto, pero como ya tengo algo de código con Flask, preferiría no cambiarlo ahora. ¿Alguna recomendación para manejar el preprocesamiento dentro de la API? Por ejemplo, normalizar imágenes o tokenizar texto.

Classical

El preprocesamiento es clave. Lo mejor es integrarlo en el mismo pipeline del modelo, ya sea con transform de torchvision o con un tokenizador de transformers. Si lo metes en la API, que sea con funciones modulares. Ejemplo:

def preprocess_image(image_bytes):
    img = Image.open(BytesIO(image_bytes))
    transform = transforms.Compose([...])
    return transform(img).unsqueeze(0)

Así puedes testearlo aparte.

Embroidery

Yo tengo una mala experiencia con Flask para modelos grandes: se bloquea con peticiones concurrentes. Por eso migré a FastAPI (asincrónico) y noté mejora. Si te da pereza migrar, al menos pon Gunicorn con workers tipo 'gevent' o 'uvicorn' (para ASGI). Y no olvides health checks en el contenedor.

FilmScore

Buena sugerencia lo de gevent. Voy a probar con Gunicorn y varios workers. Lo del health check lo tenía pendiente. Al final creo que haré una guía completa y la comparto aquí. ¡Gracias a todos!

Cars

Si haces la guía, comparte el repo. Por cierto, para dormir tranquilo, añade logging estructurado y métricas con Prometheus. El despliegue no es solo poner el modelo, es monitorizarlo.

Improv

Exacto, el logging estructurado es clave. Yo uso la librería structlog con formato JSON y lo envío a Elasticsearch. Así cuando revienta algo, no andas buscando entre texto plano. ¿Alguien ha probado opentelemetry para tracing distribuido en estos despliegues? Porque si tienes varios microservicios, se vuelve un infierno seguir la cadena sin eso.

Mac

Otelenmetry es overkill para un solo modelo, pero si ya tienes microservicios, sí, es casi obligatorio. Yo lo integré con Flask y gunicorn usando el auto-instrumentador de opentelemetry-instrumentation-flask. Eso sí, asegúrate de muestrear las trazas, porque si no, el overhead en cada request te mata. Por cierto, para métricas, mejor que Prometheus scrapee directamente al endpoint /metrics expuesto por prometheus_flask_exporter, así evitas tener que tirar logs a Elasticsearch solo para contar requests.