MLflow: Filosofía, Componentes y Arquitectura

🔬 MLflow: Filosofía, Componentes y Arquitectura

📅 Fecha: 2025-04-08

✍️ Autor: Rommel Contreras

🏛️ Contexto: Laboratorio de IA

#mlflow #machine-learning #mlops #ia-governance

📑 Tabla de contenidos

¿Qué es MLflow?
Filosofía de MLflow
Los 4 componentes principales
Tracking: Logging de experimentos
Projects: Reproducibilidad
Models: Gestión del ciclo de vida
Registry: Versionado y governance
Comparativa con alternativas
Arquitectura para tu laboratorio
Flujo práctico: Experimento a producción

¿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 1234

Registry: 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:5000

Flujo 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

Mis Blogs

miércoles, 8 de abril de 2026