🔬 MLflow: Filosofía, Componentes y Arquitectura
#mlflow
#machine-learning
#mlops
#ia-governance
📑 Tabla de contenidos
¿Qué es MLflow?
MLflow es una plataforma de código abierto para gestionar el ciclo de vida completo del machine learning, desde experimentación hasta producción.
En una frase: MLflow transforma el caos de entrenar modelos en un sistema ordenado, reproducible y auditable.
El problema que resuelve
Imagina que eres un científico de datos:
- Entrenas un modelo con 1000 hiperparámetros diferentes
- Olvidas qué valores usaste en el mejor modelo
- Tu colega ejecuta el mismo código, obtiene resultados diferentes
- El modelo funciona en tu laptop pero no en producción
- Pasan meses, quieres saber qué datos usaste
- No hay auditoría de quién cambió qué
MLflow resuelve todo esto.
Filosofía de MLflow
Principios fundamentales
| Principio | Significado | Ejemplo |
|---|---|---|
| Reproducibilidad | Mismo código = Mismo resultado, siempre | Ejecutas en 2025 y 2030, obtienes exactamente el mismo AUC |
| Trazabilidad | Registro completo de decisiones | Sé exactamente qué datos, código y parámetros produjo el mejor modelo |
| Interoperabilidad | Funciona con cualquier librería ML | TensorFlow, PyTorch, Scikit-learn, XGBoost, en el mismo sistema |
| Governance | Control de quién deployea qué | Auditoría de modelos, aprobaciones, rechazos |
| Simplicidad | Mínimo boilerplate | Agregar 3 líneas de código a tu script existente |
Antes vs Después de MLflow
| Aspecto | Sin MLflow | Con MLflow |
|---|---|---|
| Tracking de resultados | Excel + notas | Dashboard automático |
| Reproducibilidad | "Corre mi notebook entero" | Un comando: mlflow run |
| Versionado de modelos | Carpetas (model_v1, model_REAL) | Registry con control de versiones |
| Comparación de experimentos | Manual, memorizando números | UI interactiva con gráficas |
| Deploy | "Copiar el .pkl a producción" | Pipeline automático con control de versiones |
| Auditoría | No existe | Quién, cuándo, qué, por qué |
Los 4 componentes principales
MLflow consiste en 4 módulos independientes que puedes usar por separado o juntos:
┌─────────────────────────────────────────────────────────────┐
│ MLflow Platform │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Tracking │ │ Projects │ │ Models │ │
│ │ │ │ │ │ │ │
│ │ • Loguear │ │ • Reproducir │ │ • Crear │ │
│ │ • Comparar │ │ • Empaquetar │ │ • Versionear│ │
│ │ • Visualizar │ │ • Colaborar │ │ • Servir │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Registry (Modelo Central) │ │
│ │ • Versionado • Transiciones de estado │ │
│ │ • Governance • Auditoría completa │ │
│ └──────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Tracking: Logging de experimentos
¿Qué es Tracking?
Tracking = Sistema automático para registrar todo lo que sucede durante el entrenamiento de un modelo.
Qué registra MLflow Tracking
Un "Experimento" (corrida de entrenamiento) registra:
┌─ Parámetros (inputs)
│ ├─ learning_rate: 0.01
│ ├─ batch_size: 32
│ ├─ num_epochs: 100
│ └─ optimizer: "adam"
│
├─ Métricas (outputs que cambian)
│ ├─ accuracy: [0.7, 0.75, 0.82, 0.88, 0.91]
│ ├─ loss: [2.3, 2.1, 1.8, 1.5, 1.2]
│ └─ val_accuracy: [0.69, 0.74, 0.80, 0.85, 0.88]
│
├─ Artefactos (archivos)
│ ├─ model.pkl
│ ├─ scaler.pkl
│ └─ feature_importance.png
│
├─ Metadata
│ ├─ Timestamp: 2025-04-08T14:30:00
│ ├─ Usuario: rommel
│ └─ Git commit: abc123def456
│
└─ Fuente de código
├─ Script: train.py
└─ Versión Python: 3.11
Ejemplo práctico en Python
import mlflow
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score
# 1. Iniciar un experimento
mlflow.set_experiment("agua_clasificacion_v1")
# 2. Comenzar una corrida (run)
with mlflow.start_run():
# 3. Definir hiperparámetros
params = {
"n_estimators": 100,
"max_depth": 10,
"random_state": 42
}
# 4. Loguear parámetros
mlflow.log_params(params)
# 5. Entrenar modelo
model = RandomForestClassifier(**params)
model.fit(X_train, y_train)
# 6. Hacer predicciones
predictions = model.predict(X_test)
# 7. Loguear métricas
accuracy = accuracy_score(y_test, predictions)
f1 = f1_score(y_test, predictions)
mlflow.log_metric("accuracy", accuracy)
mlflow.log_metric("f1_score", f1)
# 8. Loguear artefactos
mlflow.sklearn.log_model(model, "model")
# 9. Agregar tags
mlflow.set_tag("modelo_tipo", "RandomForest")
mlflow.set_tag("dataset", "agua_ciudadanos_2025")Projects: Reproducibilidad
¿Qué es un MLflow Project?
Un MLflow Project es una forma estándar de empaquetar código ML para que cualquiera pueda ejecutarlo de forma idéntica.
Estructura de un MLflow Project
mi_proyecto_agua/
├── MLproject ← Manifest del proyecto
├── conda.yaml ← Dependencias Python
├── train.py ← Script de entrenamiento
├── evaluate.py ← Script de evaluación
├── data/
│ ├── ciudadanos.csv
│ └── reportes.csv
└── README.md
Ejecutar un MLflow Project
# Ejecutar localmente con parámetros por defecto
mlflow run . --experiment-name "agua_exp_001"
# Ejecutar con parámetros custom
mlflow run . \
--experiment-name "agua_exp_001" \
-P model_type="xgboost" \
-P n_estimators=200
# Ejecutar desde GitHub
mlflow run https://github.com/tu-usuario/agua-ml.git \
--experiment-name "agua_exp_001"Models: Gestión del ciclo de vida
¿Qué son MLflow Models?
Un MLflow Model es una forma estándar de empaquetar cualquier modelo ML con toda su metadata y dependencias.
Loguear modelos de diferentes frameworks
import mlflow
import tensorflow as tf
import torch
from sklearn.ensemble import RandomForestClassifier
# 1. TensorFlow
mlflow.tensorflow.log_model(tf_model, "model_tf")
# 2. PyTorch
mlflow.pytorch.log_model(torch_model, "model_torch")
# 3. Scikit-learn
mlflow.sklearn.log_model(sklearn_model, "model_sklearn")
# 4. Custom (función Python personalizada)
def predict_custom(model_input):
return model.predict(model_input)
mlflow.pyfunc.log_model("model_custom", python_model=predict_custom)Cargar y usar un modelo logueado
import mlflow
# Opción 1: Cargar desde un run específico
model = mlflow.pyfunc.load_model("runs/abc123/artifacts/model")
predictions = model.predict(X_test)
# Opción 2: Cargar desde el Registry
model = mlflow.pyfunc.load_model("models:/agua_clasificador/production")
# Opción 3: Servir automáticamente (REST API)
mlflow models serve -m runs/abc123/artifacts/model -p 1234Registry: Versionado y governance
¿Qué es el Model Registry?
El Model Registry es un repositorio central de modelos con control de versiones, transiciones de estado y auditoría.
Model Registry (Central)
│
├─ agua_clasificador (modelo 1)
│ ├─ v1 [archived]
│ ├─ v2 [archived]
│ ├─ v3 [staging] ← En pruebas
│ └─ v4 [production] ← En producción ⭐
│
├─ agua_predictor (modelo 2)
│ ├─ v1 [production]
│ └─ v2 [staging]
│
└─ electricidad_demanda (modelo 3)
└─ v1 [development]
Estados de un modelo (Model Stage)
| Stage | Significado | Quién lo decide | Auditoría |
|---|---|---|---|
| None | Sin asignar | Usuario | Creación |
| Staging | En pruebas, validación | Data Scientist | Quién movió, cuándo |
| Production | En uso activo | Reviewer/ML Engineer | Cuándo se deployó |
| Archived | Retirado, legacy | Administrador | Razón de retiro |
Registrar un modelo en el Registry
import mlflow
from mlflow.tracking import MlflowClient
# Opción 1: Desde un run existente
mlflow.register_model(
model_uri="runs/abc123def456/artifacts/model",
name="agua_clasificador"
)
# Opción 2: Dentro del entrenamiento
with mlflow.start_run():
model = train()
mlflow.sklearn.log_model(model, "model")
# Registrar automáticamente
mlflow.register_model(
model_uri=f"runs/{mlflow.active_run().info.run_id}/artifacts/model",
name="agua_clasificador"
)Transicionar entre estados
from mlflow.tracking import MlflowClient
client = MlflowClient()
# Pasar de Staging a Production
client.transition_model_version_stage(
name="agua_clasificador",
version=4,
stage="Production",
archive_existing_versions=True
)
# Agregar descripción
client.update_model_version(
name="agua_clasificador",
version=4,
description="Random Forest con 95% accuracy. Deployado en Cumaná."
)Comparativa: MLflow vs Alternativas
Matriz comparativa
| Característica | MLflow | Weights & Biases | Neptune | Kubeflow | DVC |
|---|---|---|---|---|---|
| Tracking de experimentos | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ |
| Reproducibilidad | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Model Registry | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ |
| Costo | ⭐⭐⭐⭐⭐ (Gratis) | ⭐⭐ (Pago) | ⭐⭐ (Pago) | ⭐⭐⭐⭐ (Gratis) | ⭐⭐⭐⭐⭐ (Gratis) |
| Control on-prem | ⭐⭐⭐⭐⭐ | ❌ | ❌ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Facilidad de uso | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐ |
¿Por qué MLflow para tu laboratorio?
| Razón | Beneficio |
|---|---|
| Código abierto | Control total, sin vendor lock-in |
| Standalone | Funciona on-prem, sin internet requerido |
| Simple | 3 líneas de código vs 50 líneas en Kubeflow |
| Multi-framework | TensorFlow, PyTorch, Scikit-learn, XGBoost... |
| Bajo costo | Gratis (contrario a Weights & Biases, Neptune) |
| Auditoría | Importante para gobierno (rastreo completo) |
Arquitectura para tu laboratorio
Stack recomendado: MLflow + Otras herramientas
┌─────────────────────────────────────────────────────────────────┐
│ Laboratorio de IA (Cumaná) │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Datos (Entrada) │ │
│ │ ├─ PostgreSQL (datos ciudadanos, reportes) │ │
│ │ └─ MinIO (fotos, GeoJSON, archivos) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Entrenamiento (MLflow Projects) │ │
│ │ ├─ train.py (código ML) │ │
│ │ ├─ MLproject (reproducibilidad) │ │
│ │ └─ conda.yaml (dependencias) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Tracking (MLflow Tracking) │ │
│ │ ├─ Parámetros logged automáticamente │ │
│ │ ├─ Métricas (accuracy, F1, AUC) │ │
│ │ └─ Dashboard UI (http://localhost:5000) │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Model Registry (MLflow Registry) │ │
│ │ ├─ agua_clasificador v4 [production] │ │
│ │ ├─ agua_predictor v2 [staging] │ │
│ │ └─ electricidad_anomalía v1 [development] │ │
│ └──────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ Deployment (MLflow Models) │ │
│ │ ├─ REST API (mlflow models serve) │ │
│ │ ├─ Batch predictions │ │
│ │ └─ Integración con Vercel/backend │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
Configuración local de MLflow
# 1. Instalar MLflow
pip install mlflow
# 2. Crear directorio de almacenamiento
mkdir -p ~/mlflow_server
cd ~/mlflow_server
# 3. Iniciar server
mlflow server \
--backend-store-uri sqlite:///mlflow.db \
--default-artifact-root ./artifacts \
--host 0.0.0.0 \
--port 5000
# 4. Abrir navegador
# http://localhost:5000Flujo práctico: De experimento a producción
Scenario: Clasificador de reportes de agua
PASO 1: Data Scientist inicia experimento
$ mlflow run . -P model_type=random_forest
✓ MLflow registra:
- Parámetros: {"model_type": "random_forest"}
- Métricas: {"accuracy": 0.92, "f1": 0.90}
- Modelo: artifact/model
- Timestamp: 2025-04-08 14:30:00
- Usuario: rommel
PASO 2: Registrar en el Registry
from mlflow.tracking import MlflowClient
client = MlflowClient()
client.copy_model_version(
src_model_uri="runs/abc123def456/artifacts/model",
dst_model_name="agua_clasificador"
)
✓ Modelo registrado como "agua_clasificador" v1
PASO 3: Pasar a Staging para validación
client.transition_model_version_stage(
name="agua_clasificador",
version=1,
stage="Staging"
)
✓ Modelo en Staging (pasa tests automáticos)
PASO 4: Aprobar y mover a Production
client.transition_model_version_stage(
name="agua_clasificador",
version=1,
stage="Production",
archive_existing_versions=True
)
✓ Modelo en Production (auditoría registrada)
PASO 5: Servir en producción
mlflow models serve \
--model-uri models:/agua_clasificador/production \
--port 8000
✓ Modelo sirviendo en REST API
