MLOps para Principiantes: Guía Completa para Desplegar Modelos de IA con Docker y Flask

Introducción

La operacionalización de modelos de inteligencia artificial (MLOps) es una práctica fundamental para que los modelos entrenados por data scientists puedan ser utilizados efectivamente en entornos de producción. Para un desarrollador o estudiante que recién comienza, términos como despliegue, contenedores y API pueden sonar complejos, pero con la guía adecuada se pueden dominar rápidamente.

Este artículo está dirigido a personas con conocimientos básicos de Python e IA que quieren dar el salto y aprender a desplegar modelos en producción usando Docker y Flask, herramientas populares y accesibles.

¿Qué es MLOps y por qué es importante?

MLOps (Machine Learning Operations) es el conjunto de prácticas que permite gestionar el ciclo de vida completo de un modelo de IA: desarrollo, prueba, integración, despliegue, monitorización y actualización.

Automatización: integración continua y despliegue continuo (CI/CD) para asegurar actualizaciones rápidas y seguras.
Reproducibilidad: ambientes controlados para que el modelo se ejecute igual en cualquier máquina.
Escalabilidad: poder atender múltiples peticiones simultáneas sin degradar el servicio.

Arquitectura Básica del Despliegue

Para desplegar un modelo de IA simple, una arquitectura muy común incluye:

Modelo entrenado: archivo con pesos ya entrenados (ejemplo: formato .pkl o .pt).
App web ligera: utilizando Flask para crear una API REST que reciba peticiones y responda con predicciones.
Contenedor Docker: que empaqueta la aplicación junto con sus dependencias para garantizar que funcione igual en cualquier entorno.

Paso 1: Crear un modelo simple y guardarlo

Para ejemplificar, usaremos Scikit-Learn para entrenar un clasificador sencillo con el dataset Iris y guardarlo con joblib:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib

# Carga datos
data = load_iris()
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, random_state=42)

# Entrena modelo
model = RandomForestClassifier(n_estimators=10)
model.fit(X_train, y_train)

# Guarda modelo
joblib.dump(model, 'model.joblib')

Paso 2: Crear una API con Flask

Este es un servidor web básico que carga el modelo y expone un endpoint para recibir datos y devolver predicciones.

from flask import Flask, request, jsonify
import joblib
import numpy as np

app = Flask(__name__)
model = joblib.load('model.joblib')

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json()
    # Esperamos una lista con las 4 características de Iris
    features = np.array(data['features']).reshape(1, -1)
    prediction = model.predict(features)
    return jsonify({'prediction': int(prediction[0])})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Paso 3: Dockerizar la aplicación

El siguiente paso es crear un Dockerfile para empaquetar el entorno completo:

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY . ./

EXPOSE 5000

CMD ["python", "app.py"]

El archivo requirements.txt debe contener:

flask
scikit-learn
joblib
numpy

Paso 4: Construir y correr el contenedor

Construir la imagen Docker desde la terminal:
```
docker build -t mlops-flask-app .
```
Ejecutar el contenedor:
```
docker run -p 5000:5000 mlops-flask-app
```

La app ahora estará accesible en http://localhost:5000/predict.

Paso 5: Probar la API

Utilizando curl o una herramienta como Postman, podemos enviar una petición POST con JSON:

curl -X POST http://localhost:5000/predict \
-H 'Content-Type: application/json' \
-d '{"features": [5.1, 3.5, 1.4, 0.2]}'

La respuesta será un JSON con la clase predicha:

{
  "prediction": 0
}

Conclusión

El despliegue de modelos de machine learning es una etapa crucial para convertir el trabajo de data science en aplicaciones reales que puedan integrarse con sistemas existentes y atender peticiones reales. En esta guía hemos visto un flujo básico y accesible para principiantes que incluye:

Entrenamiento y guardado de un modelo simple
Creación de un API REST usando Flask
Dockerización para asegurar portabilidad y reproducibilidad
Ejecutar y probar el contenedor localmente

Este flujo básico es la base para proyectos de MLOps más complejos donde se integran pipelines automáticos, monitorización, escalabilidad y seguridad. El primer paso es crear confianza y dominio sobre estos conceptos con ejemplos simples y prácticos como este.