> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/mlops-y-despliegue/mlflow.md).

# 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)              |

{% hint style="info" %}
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.
{% endhint %}

***

## Paso 1 — Alquilar un servidor en Clore.ai

1. Inicia sesión en [clore.ai](https://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
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

```dockerfile
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.

{% hint style="info" %}
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.
{% endhint %}

***

## 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:

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

### Registro básico de experimentos con PyTorch

```python
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

```python
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

```python
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:

```python
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:

```bash
# 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:

```bash
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)

```bash
# 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

```bash
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)

```bash
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:

```bash
chmod 777 /mlflow/artifacts
```

### Error de SQLite bloqueado (escrituras concurrentes)

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

```bash
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 |

{% hint style="info" %}
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.
{% endhint %}

***

## Recursos útiles

* [Documentación oficial de MLflow](https://mlflow.org/docs/latest/index.html)
* [GitHub de MLflow](https://github.com/mlflow/mlflow)
* [Docker Hub de MLflow](https://github.com/mlflow/mlflow/pkgs/container/mlflow)
* [Guía del registro de modelos de MLflow](https://mlflow.org/docs/latest/model-registry.html)
* [Referencia de la API de seguimiento de MLflow](https://mlflow.org/docs/latest/python_api/mlflow.html)

***

## 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](https://clore.ai/bare-metal) |

> 💡 Todos los ejemplos de esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/mlops-y-despliegue/mlflow.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.