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-compose si 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.