MLflow

MLflow es una plataforma de código abierto para gestionar el ciclo de vida completo del aprendizaje automático — desde el seguimiento de experimentos y el versionado de modelos hasta la implementación y el monitoreo. Usado por miles de organizaciones en todo el mundo, MLflow aporta estructura y reproducibilidad a los flujos de trabajo de ML. Ejecútalo en la nube GPU de Clore.ai para obtener un servidor de seguimiento centralizado junto con tus trabajos de entrenamiento.

---

¿Qué es MLflow?

MLflow proporciona cuatro componentes principales:

Componente	Descripción
Seguimiento	Registra parámetros, métricas, artefactos y código de ejecuciones de ML
Proyectos	Empaqueta código para ejecuciones reproducibles
Modelos	Formato estándar de modelos para implementación entre frameworks
Registro de modelos	Almacén centralizado de modelos con versionado y ciclo de vida

Frameworks compatibles (autologging integrado):

• PyTorch, TensorFlow/Keras

• Scikit-learn, XGBoost, LightGBM

• Transformers de HuggingFace

• Spark MLlib, statsmodels, Prophet

---

Requisitos previos

Requisito	Valor
VRAM de GPU	Cualquiera (el propio servidor de MLflow depende de la CPU)
Almacenamiento	20 GB+ (para artefactos)
RAM	4 GB mínimos para el servidor
Puertos	22 (SSH), 5000 (interfaz de usuario de MLflow)

El servidor de seguimiento de MLflow es ligero. Puedes ejecutarlo en una pequeña instancia de CPU y apuntar tus trabajos de entrenamiento en GPU hacia él. Como alternativa, colócalo junto con tu instancia de entrenamiento en GPU.

---

Paso 1 — Alquilar un servidor en Clore.ai

1. Inicia sesión en clore.ai.

2. Haz clic en Marketplace.

3. Para un servidor de seguimiento dedicado: filtra por RAM ≥ 8 GB (GPU opcional).

4. Para uno co-ubicado: usa tu instancia de entrenamiento existente.

5. Establece la imagen de Docker: ghcr.io/mlflow/mlflow:latest

6. Establece los puertos abiertos: 22 (SSH) y 5000 (interfaz de usuario de MLflow).

7. Haz clic en Alquilar.

---

Paso 2 — Inicia el servidor de seguimiento de MLflow

La oficial ghcr.io/mlflow/mlflow la imagen requiere sobrescribir el comando de inicio.

En la configuración de Docker de Clore.ai

Establece el comando (o la sobreescritura del entrypoint) para:

bash -c "apt-get update -q && apt-get install -y -q openssh-server && \\

    mkdir /var/run/sshd && \\

    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \\
    service ssh start && \\

    mlflow server \\

        --host 0.0.0.0 \\
        --port 5000 \\

        --default-artifact-root /mlflow/artifacts \\

        --backend-store-uri sqlite:////mlflow/mlflow.db"

Alternativa: Dockerfile personalizado

FROM ghcr.io/mlflow/mlflow:latest

RUN apt-get update && apt-get install -y \\
    openssh-server \\
    && rm -rf /var/lib/apt/lists/*

# Configurar SSH
RUN mkdir /var/run/sshd && \\
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Paquetes adicionales de Python
RUN pip install boto3 psycopg2-binary

RUN mkdir -p /mlflow/artifacts

EXPOSE 22 5000

CMD service ssh start && \\
    mlflow server \\

        --host 0.0.0.0 \\
        --port 5000 \\

        --default-artifact-root /mlflow/artifacts \\

        --backend-store-uri sqlite:////mlflow/mlflow.db

---

Paso 3 — Accede a la interfaz de usuario de MLflow

Abre tu navegador:

http://<clore-host>:<public-port-5000>

Deberías ver el panel de Experimentos de MLflow.

El backend SQLite predeterminado (mlflow.db) almacena todos los metadatos de las ejecuciones localmente. Para uso en producción o en equipo, cambia a PostgreSQL — consulta la Configuración avanzada más abajo.

---

Paso 4 — Registra tu primer experimento

Conéctate desde un trabajo de entrenamiento remoto

En tu máquina de entrenamiento (o en otra instancia de Clore.ai), establece el URI de seguimiento:

export MLFLOW_TRACKING_URI=http://<clore-host>:<public-port-5000>

Registro básico de experimentos con PyTorch

import mlflow
import mlflow.pytorch
import torch
import torch.nn as nn
import torch.optim as optim

# Conectarse al servidor de MLflow
mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("my-first-experiment")

# Definir un modelo simple
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

# Entrenamiento con seguimiento de MLflow
with mlflow.start_run(run_name="training-run-001"):
    # Registrar hiperparámetros
    params = {
        "learning_rate": 0.001,
        "batch_size": 64,
        "epochs": 100,
        "hidden_size": 256,
        "optimizer": "adam"
    }
    mlflow.log_params(params)
    
    # Inicializa el modelo
    model = SimpleNet(784, 256, 10).cuda()
    optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"])
    criterion = nn.CrossEntropyLoss()
    
    # Bucle de entrenamiento
    for epoch in range(params["epochs"]):
        loss = torch.tensor(0.5 / (epoch + 1))  # Simulado
        accuracy = 0.7 + epoch * 0.003
        
        # Registrar métricas en cada época
        mlflow.log_metrics({
            "train_loss": loss.item(),
            "train_accuracy": accuracy,
        }, step=epoch)
    
    # Registrar el modelo final
    mlflow.pytorch.log_model(model, "model")
    
    # Registrar métricas finales
    mlflow.log_metric("final_accuracy", accuracy)
    
    print(f"Ejecución registrada en MLflow. ID: {mlflow.active_run().info.run_id}")

Registro automático de HuggingFace Transformers

import mlflow
from transformers import TrainingArguments, Trainer

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("llm-finetuning")

# Habilitar el registro automático — registra automáticamente parámetros, métricas y el modelo
mlflow.transformers.autolog()

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    evaluation_strategy="epoch",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

with mlflow.start_run():
    trainer.train()

---

Paso 5 — Scikit-learn con registro automático

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("sklearn-experiments")

# Registrar todo automáticamente
mlflow.sklearn.autolog()

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

with mlflow.start_run(run_name="random-forest-v1"):
    rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
    rf.fit(X_train, y_train)
    
    score = rf.score(X_test, y_test)
    print(f"Precisión de prueba: {score:.4f}")
    # ¡Todos los parámetros, métricas y el modelo se registran automáticamente!

---

Paso 6 — Registro de modelos

Registra y administra las versiones del modelo a través de la interfaz o la API:

import mlflow

client = mlflow.MlflowClient("http://<clore-host>:<public-port-5000>")

# Registrar un modelo desde una ejecución
run_id = "your-run-id-here"
model_uri = f"runs:/{run_id}/model"

registered = mlflow.register_model(
    model_uri=model_uri,
    name="production-classifier"
)

print(f"Versión: {registered.version}")

# Cambiar la etapa del modelo
client.transition_model_version_stage(
    name="production-classifier",
    version=registered.version,
    stage="Production"
)

# Carga un modelo de producción en cualquier lugar
model = mlflow.pyfunc.load_model(
    model_uri="models:/production-classifier/Production"
)

---

Paso 7 — Sirve un modelo

MLflow puede servir cualquier modelo registrado como una API REST:

# En la instancia del servidor de MLflow
export MLFLOW_TRACKING_URI=http://localhost:5000

mlflow models serve \

    --model-uri "models:/production-classifier/Production" \

    --host 0.0.0.0 \\
    --port 5001 \

    --no-conda

Prueba el modelo servido:

curl -X POST http://<clore-host>:5001/invocations \

    -H "Content-Type: application/json" \\
    -d '{"inputs": [[1.0, 2.0, 3.0, ...]]}'

---

Configuración avanzada

Backend de PostgreSQL (Producción)

# Iniciar con PostgreSQL
mlflow server \\

    --host 0.0.0.0 \\
    --port 5000 \\

    --backend-store-uri postgresql://user:password@db-host/mlflow \

    --default-artifact-root s3://my-bucket/mlflow-artifacts

Almacenamiento de artefactos S3

pip install boto3

export AWS_ACCESS_KEY_ID=your_key
export AWS_SECRET_ACCESS_KEY=your_secret

mlflow server \\

    --host 0.0.0.0 \\
    --port 5000 \\

    --default-artifact-root s3://my-mlflow-bucket/artifacts \

    --backend-store-uri sqlite:////mlflow/mlflow.db

Autenticación (Empresarial)

pip install mlflow[auth]

mlflow server \\

    --host 0.0.0.0 \\
    --port 5000 \\

    --app-name basic-auth \

    --backend-store-uri sqlite:////mlflow/mlflow.db \

    --default-artifact-root /mlflow/artifacts

---

Comparación de ejecuciones en la interfaz de usuario

1. Abre la interfaz de usuario de MLflow en http://<clore-host>:<port>

2. Selecciona un experimento en el panel izquierdo

3. Marca las casillas junto a varias ejecuciones

4. Haz clic en Comparar para ver métricas y parámetros lado a lado

5. Usa el Pestaña de gráficos para comparación visual

---

Solución de problemas

No se puede conectar al servidor de seguimiento

mlflow.exceptions.MlflowException: API request failed with status code 503

Soluciones:

• Comprueba que el puerto 5000 esté abierto y redirigido en Clore.ai

• Verifica que el servidor se esté ejecutando: ps aux | grep mlflow

• Comprueba la conectividad: curl http://<clore-host>:<port>/health

La carga de artefactos falla

Solución: Asegúrate de que el directorio de artefactos sea escribible:

chmod 777 /mlflow/artifacts

Error de SQLite bloqueado (escrituras concurrentes)

Solución: Cambia a PostgreSQL para configuraciones de múltiples usuarios:

pip install psycopg2-binary

El registro de modelos no se muestra

Solución: Verifica que estés usando un --backend-store-uri que admita el registro (SQLite o PostgreSQL, no solo una ruta local).

---

Estimación de costos

Instancia	Caso de uso	Precio est.	Notas
CPU de 4 núcleos	Solo servidor de seguimiento	~$0,05/h	Muy ligero
RTX 3080	Entrenamiento co-ubicado	$0,05–0,19/h	Entrenamiento + MLflow
RTX 4090	Entrenamiento pesado + seguimiento	$0.14–0.42/h	Configuración más común

Ejecuta MLflow en una instancia de CPU barata y apunta todos tus trabajos de entrenamiento en GPU hacia ella. De este modo, el servidor de seguimiento se ejecuta de forma continua sin gastar créditos costosos de GPU.

---

Recursos útiles

• Documentación oficial de MLflow

• GitHub de MLflow

• Docker Hub de MLflow

• Guía del registro de modelos de MLflow

• Referencia de la API de seguimiento de MLflow

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Entrenamiento en producción	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Experimentos a gran escala	A100 80GB	bare metal

💡 Todos los ejemplos de esta guía pueden desplegarse en Clore.ai servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.