Uno de los pasos clave después de entrenar un modelo de Machine Learning es desplegarlo para que otros puedan consumirlo mediante una aplicación, API o servicio. Si bien hay muchas plataformas en la nube para esto, en este artículo te enseñaré cómo hacerlo localmente usando Docker, una herramienta liviana y poderosa para crear entornos portables y replicables.
Este enfoque te permitirá encapsular tu modelo, entorno de ejecución y dependencias en una imagen, que luego podrás ejecutar en cualquier computador sin preocuparte por conflictos o configuraciones.
¿Qué es Docker y por qué usarlo para modelos de ML?
Docker es una plataforma que permite empaquetar aplicaciones dentro de contenedores, que son entornos aislados, livianos y portables. Esto es ideal para desplegar modelos, ya que asegura que el código, las librerías, el modelo entrenado y la lógica de inferencia funcionen igual sin importar dónde se ejecuten.
Al desplegar tu modelo con Docker puedes:
- Compartirlo fácilmente con tu equipo o cliente.
- Evitar problemas de configuración en diferentes máquinas.
- Prepararte para moverlo a producción o cloud (AWS, GCP, Azure).
- Automatizar pruebas, integración continua y versionado del modelo.
Requisitos previos
- Tener Docker instalado en tu computador: https://docs.docker.com/get-docker/
- Un modelo ya entrenado (por ejemplo,
modelo_entrenado.pkl). - Python 3.8 o superior instalado.
- Familiaridad básica con terminal y scripts en Python.
Estructura del proyecto
Primero, estructura tu proyecto en una carpeta como esta:
ml-docker-deploy/
│
├── app.py # Lógica de la API para servir el modelo
├── modelo_entrenado.pkl # Modelo entrenado con joblib
├── requirements.txt # Dependencias necesarias
└── Dockerfile # Instrucciones para construir la imagen
Paso 1: Crear una API básica con Flask
app.py
from flask import Flask, request, jsonify
import joblib
import numpy as np
app = Flask(__name__)
modelo = joblib.load("modelo_entrenado.pkl")
@app.route("/predict", methods=["POST"])
def predict():
data = request.get_json()
features = np.array(data["features"]).reshape(1, -1)
prediction = modelo.predict(features)
return jsonify({"prediction": int(prediction[0])})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)
Esta API expone un endpoint /predict que espera una lista de características (features) en formato JSON.
Paso 2: Definir dependencias
requirements.txt
flask
scikit-learn
joblib
numpy
Paso 3: Crear el Dockerfile
Dockerfile
# Imagen base con Python
FROM python:3.10-slim
# Directorio de trabajo
WORKDIR /app
# Copiar archivos
COPY . /app
# Instalar dependencias
RUN pip install --no-cache-dir -r requirements.txt
# Exponer el puerto de Flask
EXPOSE 5000
# Comando para ejecutar la app
CMD ["python", "app.py"]
Paso 4: Construir y ejecutar el contenedor
Construir la imagen
Abre tu terminal y ve al directorio del proyecto:
docker build -t ml-model-api .
Ejecutar el contenedor
docker run -p 5000:5000 ml-model-api
Esto expone tu modelo localmente en http://localhost:5000.
Paso 5: Probar la API
Usa curl, Postman o cualquier cliente HTTP:
curl -X POST http://localhost:5000/predict \
-H "Content-Type: application/json" \
-d '{"features": [5.1, 3.5, 1.4, 0.2]}'
Respuesta esperada:
{"prediction": 0}
Buenas prácticas y siguientes pasos
- Agrega validación de entrada y manejo de errores.
- Integra un pipeline completo (
scaler+ modelo) dentro del contenedor. - Versiona tus modelos y automatiza despliegues con CI/CD.
- Usa
docker-composesi necesitas una arquitectura más compleja.
Conclusión
Desplegar un modelo con Docker te da portabilidad, reproducibilidad y control total sobre el entorno de ejecución. Aunque este artículo cubre un caso local, los mismos principios te servirán para escalar tu solución a servicios en la nube o microservicios productivos. Con este flujo tienes el primer paso concreto para llevar tu modelo del notebook a una API funcional y real.
