MLOps Local: Pipeline Completo de Machine Learning en Homelab (Guía Completa 2026)

📋 TL;DR (Resumen Ejecutivo)

MLOps (Machine Learning Operations) es la práctica de operacionalizar el ciclo de vida completo de Machine Learning, desde datos hasta deployment y monitoreo. Esta guía te enseñará a montar un pipeline MLOps completo en tu homelab usando MLflow, desde experiment tracking hasta model serving, sin depender de servicios cloud.

Lo que conseguirás:

✅ Pipeline completo: datos → entrenamiento → deployment → monitoring
✅ Experiment tracking con MLflow para registrar métricas, parámetros y modelos
✅ Model registry para versionado y gestión de modelos en producción
✅ Serving de modelos con API REST para integración con aplicaciones
✅ Integración con Ollama para tracking de fine-tuning de LLMs
✅ Monitoring y observabilidad con Prometheus y Grafana

Tiempo de lectura: ~30 minutos | Nivel: Avanzado

—

📚 Tabla de Contenidos

¿Qué es MLOps y Por Qué Importa?
ML Básico vs MLOps Profesional
Arquitectura del Pipeline MLOps Local
MLflow vs Alternativas: Comparativa Completa
Instalación MLflow con [Docker-2025/) Compose](#instalacion)
Pipeline Completo Paso a Paso
Experiment Tracking: Registro de Métricas y Parámetros
Model Registry: Versionado y Staging
Deployment Local: Serving con MLflow
Monitoring y Observabilidad
Integración con Ollama: Fine-tuning Tracking
Casos de Uso Prácticos para Homelab
Troubleshooting Errores Comunes
Mejores Prácticas MLOps
Preguntas Frecuentes
Conclusión y Próximos Pasos

—

> 📅 Última actualización: Enero 2026

> ✅ Verificado con: MLflow v2.8.1 – Enero 2026

> 🔄 Próxima revisión: Abril 2026

—

Introducción

Si has entrenado modelos de Machine Learning, probablemente conoces el problema: entrenaste un modelo excelente en tu notebook, pero ¿cómo lo pones en producción? ¿Cómo versionas los modelos? ¿Cómo rastrear qué parámetros funcionaron mejor? ¿Cómo detectar cuando el modelo empieza a degradarse?

El problema: El 90% de los modelos de ML nunca llegan a producción. No porque sean malos, sino porque falta la infraestructura para operacionalizarlos. Sin MLOps, cada experimento es una caja negra, los modelos se pierden en carpetas locales, y no hay forma de reproducir resultados.

La solución: MLOps es el conjunto de prácticas que transforma el desarrollo de ML de un proceso artesanal a uno profesional. Con MLflow, puedes tener un pipeline completo en tu homelab: desde experiment tracking hasta model serving, todo local y bajo tu control.

En esta guía completa aprenderás:

Cómo instalar y configurar MLflow en Docker
Crear un pipeline completo de ML con tracking automático
Versionado de modelos con Model Registry
Deployment de modelos con API REST
Integración con Ollama para tracking de fine-tuning
Monitoring y detección de drift
Casos de uso prácticos para homelab

Ya seas data scientist, ML engineer o entusiasta de IA, esta guía te dará las herramientas para llevar tus modelos de ML al siguiente nivel.

—

¿Qué es MLOps y Por Qué Importa?

MLOps: Operacionalización de Machine Learning

MLOps (Machine Learning Operations) es la práctica de aplicar principios de DevOps al ciclo de vida de Machine Learning. A diferencia de solo entrenar modelos, MLOps incluye:

Versionado de datos: Tracking de qué datasets se usaron en cada experimento
Experiment tracking: Registro de métricas, parámetros, código y resultados
Model registry: Versionado y gestión de modelos (staging, production)
Deployment automatizado: Serving de modelos con APIs, contenedores, etc.
Monitoring: Detección de drift, degradación de performance, y alertas

Características principales:

✅ Reproducibilidad: Cualquier experimento puede reproducirse exactamente
✅ Trazabilidad: Sabes qué parámetros, datos y código generaron cada modelo
✅ Colaboración: Múltiples personas pueden trabajar en el mismo proyecto
✅ Automatización: Pipeline completo desde datos hasta producción
✅ Observabilidad: Monitoreo continuo de modelos en producción

¿Por Qué Usar MLOps?

Casos de uso ideales:

Entrenamiento de modelos LLM: Tracking de fine-tuning con Ollama, comparación de diferentes modelos
Clasificación de documentos: Pipeline para Paperless-ngx con versionado de modelos
Detección de anomalías: Modelos para Prometheus con monitoring continuo
Proyectos de ML profesionales: Cualquier proyecto que requiera reproducibilidad y trazabilidad

NO uses MLOps si:

❌ Solo haces experimentos exploratorios rápidos (Jupyter notebooks son suficientes)
❌ Tu modelo nunca va a producción (aunque el tracking sigue siendo útil)

—

ML Básico vs MLOps Profesional

Enfoque Tradicional (Sin MLOps)

TEXT

┌─────────────┐
│  Notebook   │ → Entrenar modelo
└─────────────┘
       │
       ▼
┌─────────────┐
│  Modelo.pkl │ → Guardar en carpeta local
└─────────────┘
       │
       ❌ ¿Qué parámetros usé?
       ❌ ¿Qué datos?
       ❌ ¿Cómo lo despliego?
       ❌ ¿Está funcionando bien?

Problemas:

❌ No hay registro de qué funcionó y qué no
❌ Modelos se pierden en carpetas
❌ Imposible reproducir resultados
❌ No hay forma de comparar experimentos
❌ Deployment manual y propenso a errores

Enfoque MLOps Profesional

TEXT

┌─────────────┐
│   Datos     │ → Versionado con DVC
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Training   │ → MLflow tracking (métricas, parámetros)
└──────┬──────┘
       │
       ▼
┌─────────────┐
│   Registry  │ → Versionado, staging, production
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Deployment │ → API REST automática
└──────┬──────┘
       │
       ▼
┌─────────────┐
│  Monitoring │ → Drift detection, métricas
└─────────────┘

Ventajas:

✅ Todo está registrado y trazable
✅ Modelos versionados y gestionados
✅ Deployment automatizado
✅ Monitoring continuo
✅ Reproducibilidad garantizada

—

Arquitectura del Pipeline MLOps Local

Componentes del Pipeline

TEXT

┌─────────────────────────────────────────────────────────┐
│                    DATA SOURCES                          │
│  (CSV, Parquet, PostgreSQL, MinIO, Prometheus)         │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              PREPROCESSING LAYER                         │
│  (DVC versioning, feature engineering, validation)      │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              TRAINING LAYER                              │
│  (MLflow tracking, hyperparameter tuning, GPU support)  │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              EVALUATION LAYER                            │
│  (Metrics, validation, A/B testing, model comparison)   │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              REGISTRY LAYER                              │
│  (Model versioning, staging, production promotion)      │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              DEPLOYMENT LAYER                            │
│  (MLflow serving, Docker, Kubernetes, API REST)         │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              MONITORING LAYER                            │
│  (Drift detection, performance metrics, Prometheus)     │
└─────────────────────────────────────────────────────────┘

Stack Tecnológico

MLflow: Experiment tracking, model registry, serving
PostgreSQL-guia-completa-tutorial-2025/)-mongodb-guia-completa-tutorial-2025/): Backend para MLflow tracking
MinIO/S3: Almacenamiento de artifacts (modelos, datasets)
Prometheus + Grafana: Monitoring y observabilidad
Docker: Containerización de todo el stack

—

MLflow vs Alternativas: Comparativa Completa

Característica	MLflow	Weights & Biases	TensorBoard	Neptune
Open Source	✅ 100%	⚠️ Freemium	✅ 100%	⚠️ Freemium
Model Registry	✅ Completo	✅ Completo	❌ No	✅ Completo
Local Deployment	✅ Docker	❌ Solo Cloud	✅ Local	❌ Solo Cloud
Experiment Tracking	✅ Excelente	✅ Excelente	⚠️ Limitado	✅ Excelente
Integración Ollama	✅ Python API	⚠️ Limitada	❌ No	⚠️ Limitada
Costo Homelab	✅ Gratis	⚠️ Plan pago	✅ Gratis	⚠️ Plan pago
UI Dashboard	✅ Incluida	✅ Incluida	⚠️ Básica	✅ Incluida
Serving Integrado	✅ MLflow Models	❌ No	❌ No	❌ No

Ventajas de MLflow:

100% Open Source: Sin límites ni costos ocultos
Deployment local: Todo funciona en tu homelab
Serving integrado: API REST lista para usar
Model Registry: Versionado profesional de modelos
Comunidad activa: Miles de usuarios y contribuidores

—

Instalación MLflow con Docker Compose

Requisitos Previos

Docker y Docker Compose instalados
Mínimo 4GB RAM (recomendado 8GB+)
10GB espacio en disco para artifacts
PostgreSQL (incluido en docker-compose)

Docker Compose Completo

Crea un archivo docker-compose.yml:

YAML

version: '3.8'

services:
  postgres:
    image: postgres:15
    container_name: mlflow-postgres
    restart: unless-stopped
    environment:
      - POSTGRES_USER=mlflow
      - POSTGRES_PASSWORD=mlflow
      - POSTGRES_DB=mlflow
    volumes:
      - mlflow-postgres-data:/var/lib/postgresql/data
    networks:
      - mlflow

  mlflow:
    image: ghcr.io/mlflow/mlflow:v2.8.1
    container_name: mlflow-server
    restart: unless-stopped
    command: >
      mlflow server
      --backend-store-uri postgresql://mlflow:mlflow@postgres:5432/mlflow
      --default-artifact-root s3://mlflow-artifacts/
      --host 0.0.0.0
      --port 5000
    ports:
      - "5000:5000"
    environment:
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
      - MLFLOW_S3_ENDPOINT_URL=http://minio:9000
    depends_on:
      - postgres
      - minio
    networks:
      - mlflow

  minio:
    image: minio/minio:latest
    container_name: mlflow-minio
    restart: unless-stopped
    command: server /data --console-address ":9001"
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin
    volumes:
      - mlflow-minio-data:/data
    networks:
      - mlflow

volumes:
  mlflow-postgres-data:
  mlflow-minio-data:

networks:
  mlflow:
    driver: bridge

Iniciar MLflow

BASH

# Iniciar servicios
docker-compose up -d

# Verificar que está corriendo
docker logs mlflow-server

# Acceder a la UI
# http://localhost:5000

Configurar Bucket S3 en MinIO

BASH

# Acceder a MinIO Console
# http://localhost:9001
# Usuario: minioadmin
# Contraseña: minioadmin

# Crear bucket "mlflow-artifacts"
# O usar mc (MinIO Client):
docker exec mlflow-minio mc mb /data/mlflow-artifacts

—

Pipeline Completo Paso a Paso

1. Preprocessing de Datos

Crea pipeline/preprocess.py:

PYTHON

import pandas as pd
import mlflow
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("homelab-classification")

# Cargar datos
df = pd.read_csv("data/dataset.csv")

# Preprocessing
X = df.drop("target", axis=1)
y = df["target"]

# Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Normalización
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Guardar datos procesados
pd.DataFrame(X_train_scaled).to_csv("data/X_train.csv", index=False)
pd.DataFrame(X_test_scaled).to_csv("data/X_test.csv", index=False)
y_train.to_csv("data/y_train.csv", index=False)
y_test.to_csv("data/y_test.csv", index=False)

print("✅ Preprocessing completado")

2. Entrenamiento con Tracking

Crea pipeline/train.py:

PYTHON

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import pandas as pd
import pickle

mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("homelab-classification")

# Cargar datos preprocesados
X_train = pd.read_csv("data/X_train.csv")
X_test = pd.read_csv("data/X_test.csv")
y_train = pd.read_csv("data/y_train.csv").squeeze()
y_test = pd.read_csv("data/y_test.csv").squeeze()

# Entrenar con tracking
with mlflow.start_run():
    # Parámetros
    n_estimators = 100
    max_depth = 10
    min_samples_split = 2
    
    mlflow.log_param("n_estimators", n_estimators)
    mlflow.log_param("max_depth", max_depth)
    mlflow.log_param("min_samples_split", min_samples_split)
    mlflow.log_param("dataset", "dataset.csv")
    mlflow.log_param("preprocessing", "StandardScaler")
    
    # Entrenar modelo
    model = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        min_samples_split=min_samples_split,
        random_state=42
    )
    model.fit(X_train, y_train)
    
    # Evaluar
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_test, y_pred)
    precision = precision_score(y_test, y_pred, average='weighted')
    recall = recall_score(y_test, y_pred, average='weighted')
    f1 = f1_score(y_test, y_pred, average='weighted')
    
    # Log métricas
    mlflow.log_metric("accuracy", accuracy)
    mlflow.log_metric("precision", precision)
    mlflow.log_metric("recall", recall)
    mlflow.log_metric("f1_score", f1)
    
    # Guardar modelo
    mlflow.sklearn.log_model(model, "model")
    
    # Guardar artifacts adicionales
    with open("feature_importance.pkl", "wb") as f:
        pickle.dump(model.feature_importances_, f)
    mlflow.log_artifact("feature_importance.pkl")
    
    print(f"✅ Modelo entrenado")
    print(f"   Accuracy: {accuracy:.4f}")
    print(f"   Precision: {precision:.4f}")
    print(f"   Recall: {recall:.4f}")
    print(f"   F1-Score: {f1:.4f}")
    print(f"   Run ID: {mlflow.active_run().info.run_id}")

3. Evaluación y Comparación

PYTHON

from mlflow.tracking import MlflowClient

client = MlflowClient("http://localhost:5000")

# Obtener todos los runs del experimento
experiment = client.get_experiment_by_name("homelab-classification")
runs = client.search_runs(experiment.experiment_id)

# Comparar runs
for run in runs[:5]:  # Top 5
    print(f"Run ID: {run.info.run_id}")
    print(f"  Accuracy: {run.data.metrics.get('accuracy', 0):.4f}")
    print(f"  Params: {run.data.params}")
    print()

—

Experiment Tracking: Registro de Métricas y Parámetros

Qué Registrar en MLflow

Parámetros:

Hiperparámetros del modelo (learning rate, epochs, etc.)
Configuración de datos (dataset usado, split ratio)
Configuración de preprocessing (normalización, encoding)

Métricas:

Métricas de evaluación (accuracy, precision, recall, F1)
Métricas de entrenamiento (loss, validation loss)
Métricas de negocio (si aplica)

Artifacts:

Modelo entrenado
Gráficos (curvas de aprendizaje, confusion matrix)
Datos procesados (si es necesario)
Logs de entrenamiento

Ejemplo Completo de Tracking

PYTHON

import mlflow
import mlflow.sklearn
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns

with mlflow.start_run(run_name="experiment-v1"):
    # Parámetros
    params = {
        "n_estimators": 100,
        "max_depth": 10,
        "learning_rate": 0.01
    }
    mlflow.log_params(params)
    
    # Entrenar y evaluar
    model = train_model(params)
    metrics = evaluate_model(model, X_test, y_test)
    mlflow.log_metrics(metrics)
    
    # Artifacts: Confusion Matrix
    cm = confusion_matrix(y_test, y_pred)
    plt.figure(figsize=(10, 8))
    sns.heatmap(cm, annot=True, fmt='d')
    plt.title("Confusion Matrix")
    plt.savefig("confusion_matrix.png")
    mlflow.log_artifact("confusion_matrix.png")
    
    # Artifacts: Classification Report
    report = classification_report(y_test, y_pred, output_dict=True)
    import json
    with open("classification_report.json", "w") as f:
        json.dump(report, f)
    mlflow.log_artifact("classification_report.json")
    
    # Guardar modelo
    mlflow.sklearn.log_model(model, "model")

—

Model Registry: Versionado y Staging

Registrar Modelo en Registry

PYTHON

from mlflow.tracking import MlflowClient

client = MlflowClient("http://localhost:5000")

# Obtener el mejor run
best_run = client.search_runs(
    experiment_ids=[experiment.experiment_id],
    order_by=["metrics.accuracy DESC"],
    max_results=1
)[0]

# Registrar modelo
model_name = "homelab-classifier"
model_version = client.create_model_version(
    name=model_name,
    source=f"runs:/{best_run.info.run_id}/model",
    run_id=best_run.info.run_id
)

print(f"✅ Modelo registrado: {model_name} v{model_version.version}")

Transicionar a Staging

PYTHON

# Transicionar a Staging
client.transition_model_version_stage(
    name=model_name,
    version=model_version.version,
    stage="Staging"
)

# Probar modelo en Staging
staging_model = mlflow.pyfunc.load_model(f"models:/{model_name}/Staging")

Transicionar a Production

PYTHON

# Después de validar en Staging, promover a Production
client.transition_model_version_stage(
    name=model_name,
    version=model_version.version,
    stage="Production"
)

# Cargar modelo de producción
production_model = mlflow.pyfunc.load_model(f"models:/{model_name}/Production")

—

Deployment Local: Serving con MLflow

MLflow Serving con Docker

Añade al docker-compose.yml:

YAML

mlflow-serving:
    image: ghcr.io/mlflow/mlflow:v2.8.1
    container_name: mlflow-serving
    restart: unless-stopped
    command: >
      mlflow models serve
      -m models:/homelab-classifier/Production
      -h 0.0.0.0
      -p 8000
      --no-conda
    ports:
      - "8000:8000"
    environment:
      - MLFLOW_TRACKING_URI=http://mlflow:5000
      - MLFLOW_BACKEND_STORE_URI=postgresql://mlflow:mlflow@postgres:5432/mlflow
      - MLFLOW_DEFAULT_ARTIFACT_ROOT=s3://mlflow-artifacts/
      - AWS_ACCESS_KEY_ID=minioadmin
      - AWS_SECRET_ACCESS_KEY=minioadmin
      - MLFLOW_S3_ENDPOINT_URL=http://minio:9000
    depends_on:
      - mlflow
      - postgres
      - minio
    networks:
      - mlflow

Hacer Predicciones

PYTHON

import requests
import json

# Datos de ejemplo
data = {
    "dataframe_records": [
        {"feature1": 1.0, "feature2": 2.0, "feature3": 3.0},
        {"feature1": 4.0, "feature2": 5.0, "feature3": 6.0}
    ]
}

# Hacer request
response = requests.post(
    "http://localhost:8000/invocations",
    json=data,
    headers={"Content-Type": "application/json"}
)

predictions = response.json()
print(f"Predicciones: {predictions}")

—

Monitoring y Observabilidad

Integración con Prometheus

MLflow expone métricas en formato Prometheus. Crea prometheus.yml:

YAML

scrape_configs:
  - job_name: 'mlflow'
    static_configs:
      - targets: ['mlflow:5000']

Métricas Clave a Monitorear

Model performance: Accuracy, precision, recall en producción
Prediction latency: Tiempo de respuesta de predicciones
Request rate: Número de predicciones por minuto
Error rate: Porcentaje de errores en predicciones

Detección de Drift

PYTHON

from evidently import ColumnMapping
from evidently.report import Report
from evidently.metric_preset import DataDriftPreset

# Comparar datos de entrenamiento vs producción
report = Report(metrics=[DataDriftPreset()])
report.run(
    reference_data=train_data,
    current_data=production_data,
    column_mapping=column_mapping
)

# Si hay drift, alertar
if report.as_dict()["metrics"][0]["result"]["dataset_drift"]:
    print("⚠️ Drift detectado!")

—

Integración con Ollama: Fine-tuning Tracking

Tracking de Fine-tuning

PYTHON

import mlflow
import requests
import json

mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("ollama-fine-tuning")

with mlflow.start_run():
    # Parámetros de fine-tuning
    model_name = "llama2"
    epochs = 3
    learning_rate = 0.0001
    batch_size = 4
    
    mlflow.log_param("model", model_name)
    mlflow.log_param("epochs", epochs)
    mlflow.log_param("learning_rate", learning_rate)
    mlflow.log_param("batch_size", batch_size)
    
    # Ejecutar fine-tuning (ejemplo con API Ollama)
    # Nota: Esto es un ejemplo, ajusta según tu setup
    training_data = {
        "model": model_name,
        "training_data": "data/training.jsonl",
        "epochs": epochs
    }
    
    # Log dataset usado
    mlflow.log_artifact("data/training.jsonl")
    
    # Simular fine-tuning (ajusta según tu implementación)
    # response = requests.post("http://ollama:11434/api/train", json=training_data)
    
    # Log métricas (si Ollama las proporciona)
    # mlflow.log_metric("loss", response.json().get("loss", 0))
    # mlflow.log_metric("perplexity", response.json().get("perplexity", 0))
    
    print("✅ Fine-tuning tracked en MLflow")

—

Casos de Uso Prácticos para Homelab

1. Clasificación de Documentos (Paperless-ngx)

Pipeline completo:

Datos: Extraer texto de documentos con OCR
Preprocessing: Limpieza, tokenización, embeddings
Training: Clasificador de categorías
Evaluation: Métricas de precisión por categoría
Deployment: API REST para clasificación automática
Monitoring: Detección de drift en nuevas categorías

2. Detección de Anomalías (Prometheus)

Pipeline de ML para observabilidad:

Datos: Métricas de Prometheus (CPU, memoria, red)
Preprocessing: Normalización, feature engineering
Training: Modelo de detección de anomalías (Isolation Forest)
Evaluation: F1-score, recall para anomalías
Deployment: Integración con Prometheus AlertManager
Monitoring: Alertas cuando modelo detecta anomalías

3. Fine-tuning de LLMs (Ollama)

Tracking de fine-tuning:

Datos: Dataset de fine-tuning
Training: Fine-tuning con Ollama
Tracking: Métricas de pérdida, perplexity
Registry: Versionado de modelos fine-tuned
Deployment: Serving con Ollama
Monitoring: Performance del modelo fine-tuned

—

Troubleshooting Errores Comunes

Problema: MLflow no se conecta a PostgreSQL

Solución:

Verificar que PostgreSQL está corriendo:

BASH

docker ps | grep postgres

Comprobar credenciales:

BASH

docker exec mlflow-postgres psql -U mlflow -d mlflow -c "SELECT 1;"

Revisar logs:

BASH

docker logs mlflow-server

Problema: Artifacts no se guardan en S3/MinIO

Solución:

Verificar credenciales AWS/MinIO:

BASH

docker exec mlflow-minio mc config host ls

Comprobar que el bucket existe:

BASH

docker exec mlflow-minio mc ls minio/mlflow-artifacts

Crear bucket si no existe:

BASH

docker exec mlflow-minio mc mb minio/mlflow-artifacts

Problema: Model serving no funciona

Solución:

Verificar que el modelo está en Production:

BASH

curl http://localhost:5000/api/2.0/mlflow/registered-models/get-latest-versions?name=homelab-classifier

Comprobar dependencias:

BASH

docker exec mlflow-serving pip list

Revisar logs:

BASH

docker logs mlflow-serving

Problema: Alto consumo de recursos

Solución:

Limitar número de runs retenidos:

– Configurar políticas de retención en MLflow

– Archivar runs antiguos

Optimizar almacenamiento:

– Usar compresión para artifacts grandes

– Limpiar artifacts no utilizados

—

Mejores Prácticas MLOps

1. Versionado de Datos

Usa DVC (Data Version Control) junto con MLflow:

BASH

# Instalar DVC
pip install dvc

# Inicializar
dvc init

# Añadir datos
dvc add data/dataset.csv
git add data/dataset.csv.dvc

# En MLflow, referencia el commit de DVC
mlflow.log_param("data_version", "dvc:abc123")

2. Naming de Experimentos

Usa nombres descriptivos:

PYTHON

# ❌ Malo
mlflow.set_experiment("test")

# ✅ Bueno
mlflow.set_experiment("homelab-classification-2026-01-26")
mlflow.set_experiment("ollama-llama2-finetuning-v1")

3. Model Registry

Mantener máximo 3-5 modelos en Production: Evita confusión
Usar staging: Siempre valida en staging antes de production
Documentar cambios: Añade notas al registrar modelos

4. Monitoring Continuo

Implementar drift detection: Usa Evidently AI o similar
Alertas automáticas: Configura alertas en Prometheus
Revisar métricas semanalmente: Identifica degradación temprana

5. CI/CD para ML

Automatiza deployment con GitHub Actions:

YAML

# .github/workflows/ml-deploy.yml
name: ML Deployment
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Train and Deploy
        run: |
          python pipeline/train.py
          # Promover a production si métricas son buenas

—

Preguntas Frecuentes

¿MLflow es gratis?

Respuesta: Sí, MLflow es 100% open source y gratis. No hay límites de uso ni costos ocultos.

¿Necesito GPU para MLOps?

Respuesta: No, MLOps (tracking, registry, serving) no requiere GPU. Solo el entrenamiento de modelos puede requerir GPU dependiendo del modelo.

¿Puedo usar MLflow con modelos de Ollama?

Respuesta: Sí, puedes trackear fine-tuning y métricas de modelos Ollama. Ver sección «Integración con Ollama».

¿Cómo versiono datasets?

Respuesta: Usa DVC (Data Version Control) junto con MLflow. DVC versiona datos, MLflow versiona modelos.

¿MLflow funciona con Kubernetes?

Respuesta: Sí, MLflow puede desplegarse en Kubernetes. Usa el chart de Helm oficial.

¿Cómo comparo múltiples experimentos?

Respuesta: Usa la UI de MLflow (http://localhost:5000) o el API:

PYTHON

runs = client.search_runs(experiment_id, order_by=["metrics.accuracy DESC"])

¿Puedo usar MLflow sin Docker?

Respuesta: Sí, puedes instalar MLflow con pip:

BASH

pip install mlflow
mlflow server --backend-store-uri sqlite:///mlflow.db

¿Cómo hago backup de MLflow?

Respuesta: Haz backup de:

Base de datos PostgreSQL
Bucket S3/MinIO con artifacts
Configuraciones en código

¿MLflow soporta modelos de TensorFlow/PyTorch?

Respuesta: Sí, MLflow soporta múltiples frameworks:

TensorFlow (mlflow.tensorflow)
PyTorch (mlflow.pytorch)
Scikit-learn (mlflow.sklearn)
XGBoost (mlflow.xgboost)
Y más…

¿Cómo detecto drift en producción?

Respuesta: Usa Evidently AI o implementa tu propia solución:

PYTHON

from evidently import DataDriftPreset
report = Report(metrics=[DataDriftPreset()])
report.run(reference_data=train, current_data=production)

¿MLflow es solo para Python?

Respuesta: Principalmente sí, pero hay APIs REST que permiten integración desde otros lenguajes.

¿Cómo escalo MLflow para múltiples usuarios?

Respuesta: MLflow soporta múltiples usuarios. Cada usuario puede tener sus propios experimentos o compartir experimentos.

¿Puedo usar MLflow con Jupyter notebooks?

Respuesta: Sí, MLflow funciona perfectamente en Jupyter notebooks. Solo importa mlflow y usa las funciones normalmente.

—

Conclusión y Próximos Pasos

MLOps transforma el desarrollo de Machine Learning de un proceso artesanal a uno profesional. Con MLflow en tu homelab, tienes acceso a las mismas herramientas que usan las empresas más grandes, pero bajo tu control y sin costos.

Lo que has aprendido:

✅ Cómo instalar y configurar MLflow en Docker
✅ Crear un pipeline completo de ML con tracking automático
✅ Versionado de modelos con Model Registry
✅ Deployment de modelos con API REST
✅ Integración con Ollama para tracking de fine-tuning
✅ Monitoring y detección de drift
✅ Casos de uso prácticos para homelab

Próximos pasos recomendados:

Explorar MLflow Projects: Empaqueta tu código ML para reproducibilidad
Integrar con DVC: Versiona datasets junto con modelos
Automatizar con CI/CD: GitHub Actions para deployment automático
Implementar drift detection: Evidently AI para monitoreo continuo
Escalar con Kubernetes: Despliega MLflow en K8s para producción

📦 Descargar Ejemplos

Todos los ejemplos de código y configuraciones están disponibles en GitHub:

🔗 https://github.com/ziruelen/learningaiagents/tree/main/homelab/mlops-pipeline

Artículos Relacionados

¿Tienes preguntas o quieres compartir tu experiencia con MLOps? Déjanos un comentario o únete a nuestra comunidad en Discord.

—

Última actualización: Enero 2026 | MLflow v2.8.1

MLOps Local: Pipeline Completo de Machine Learning en Homelab (Guía Completa 2026)

MLOps Local: Pipeline Completo de Machine Learning en Homelab (Guía Completa 2026)

📋 TL;DR (Resumen Ejecutivo)

📚 Tabla de Contenidos

Introducción

¿Qué es MLOps y Por Qué Importa?

MLOps: Operacionalización de Machine Learning

¿Por Qué Usar MLOps?

ML Básico vs MLOps Profesional

Enfoque Tradicional (Sin MLOps)

Enfoque MLOps Profesional

Arquitectura del Pipeline MLOps Local

Componentes del Pipeline

Stack Tecnológico

MLflow vs Alternativas: Comparativa Completa

Instalación MLflow con Docker Compose

Requisitos Previos

Docker Compose Completo

Iniciar MLflow

Configurar Bucket S3 en MinIO

Pipeline Completo Paso a Paso

1. Preprocessing de Datos

2. Entrenamiento con Tracking

3. Evaluación y Comparación

Experiment Tracking: Registro de Métricas y Parámetros

Qué Registrar en MLflow

Ejemplo Completo de Tracking

Model Registry: Versionado y Staging

Registrar Modelo en Registry

Transicionar a Staging

Transicionar a Production

Deployment Local: Serving con MLflow

MLflow Serving con Docker

Hacer Predicciones

Monitoring y Observabilidad

Integración con Prometheus

Métricas Clave a Monitorear

Detección de Drift

Integración con Ollama: Fine-tuning Tracking

Tracking de Fine-tuning

Casos de Uso Prácticos para Homelab

1. Clasificación de Documentos (Paperless-ngx)

2. Detección de Anomalías (Prometheus)

3. Fine-tuning de LLMs (Ollama)

Troubleshooting Errores Comunes

Problema: MLflow no se conecta a PostgreSQL

Problema: Artifacts no se guardan en S3/MinIO

Problema: Model serving no funciona

Problema: Alto consumo de recursos

Mejores Prácticas MLOps

1. Versionado de Datos

2. Naming de Experimentos

3. Model Registry

4. Monitoring Continuo

5. CI/CD para ML

Preguntas Frecuentes

¿MLflow es gratis?

¿Necesito GPU para MLOps?

¿Puedo usar MLflow con modelos de Ollama?

¿Cómo versiono datasets?

¿MLflow funciona con Kubernetes?

¿Cómo comparo múltiples experimentos?

¿Puedo usar MLflow sin Docker?

¿Cómo hago backup de MLflow?

¿MLflow soporta modelos de TensorFlow/PyTorch?

¿Cómo detecto drift en producción?

¿MLflow es solo para Python?

¿Cómo escalo MLflow para múltiples usuarios?

¿Puedo usar MLflow con Jupyter notebooks?

Conclusión y Próximos Pasos

Por ziru

Entradas relacionadas

CrowdSec: Firewall Colaborativo con IA para Homelab (Guía Completa 2026)

Immich Avanzado: Migración desde Google Photos, External Libraries y Optimización Profesional (Guía Completa 2026)

WireGuard Manual Self-Hosted: VPN 100% Control en tu Homelab (Guía Completa 2026)

Te has perdido

MLOps Local: Pipeline Completo de Machine Learning en Homelab (Guía Completa 2026)

CrowdSec: Firewall Colaborativo con IA para Homelab (Guía Completa 2026)

Immich Avanzado: Migración desde Google Photos, External Libraries y Optimización Profesional (Guía Completa 2026)

WireGuard Manual Self-Hosted: VPN 100% Control en tu Homelab (Guía Completa 2026)