Capítulo 1: ¿Qué es MLOps?

Introducción

MLOps (Operaciones de Aprendizaje Automático) es un conjunto de prácticas que tiene como objetivo desplegar y mantener modelos de aprendizaje automático en producción de manera confiable y eficiente. Combina Machine Learning, DevOps e Ingeniería de Datos para automatizar y estandarizar el ciclo de vida del ML.

Definition

MLOps = Machine Learning + DevOps + Ingeniería de Datos

Es la disciplina de entregar sistemas de ML con el mismo rigor y confiabilidad que los sistemas de software tradicionales.

El problema que resuelve MLOps

El desafío del desarrollo de ML

El desarrollo de software tradicional sigue un camino bien entendido:

Code → Build → Test → Deploy → Monitor

El aprendizaje automático añade una complejidad significativa:

Data → Feature Engineering → Training → Evaluation → Deployment → Monitoring → Retraining
     ↑                                                                              ↓
     └──────────────────────────────────────────────────────────────────────────────┘

Por qué el 87% de los proyectos de ML nunca llegan a producción

Según investigaciones de la industria:

Desafío	Impacto
Poca reproducibilidad del modelo	No se pueden recrear los resultados
Falta de versionado	Deriva de código, datos y modelo
Despliegue manual	Lanzamientos lentos y propensos a errores
Sin monitoreo	Fallos silenciosos del modelo
Deuda técnica	Sistemas insostenibles

Principios fundamentales de MLOps

1. Automatización

Todo lo que pueda ser automatizado, debe ser automatizado:

# Example: Automated training pipeline trigger
name: ML Training Pipeline
on:
  schedule:
    - cron: '0 0 * * 0'  # Weekly retraining
  push:
    paths:
      - 'data/**'
      - 'src/training/**'

jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'
      
      - name: Train model
        run: |
          pip install -r requirements.txt
          python src/train.py
      
      - name: Evaluate model
        run: python src/evaluate.py
      
      - name: Register model
        if: success()
        run: python src/register_model.py

2. Versionar todo

Haga seguimiento de todos los componentes de su sistema de ML:

# Code versioning
git add .
git commit -m "feat: add new feature engineering step"

# Data versioning with DVC
dvc add data/training_data.csv
git add data/training_data.csv.dvc
git commit -m "data: update training dataset v2.1"

# Model versioning
mlflow models log \
  --model-uri runs:/<run-id>/model \
  --registered-model-name "production-model"

3. Integración y Despliegue Continuos (CI/CD)

4. Monitoreo y Observabilidad

Los modelos en producción requieren monitoreo constante:

# Example: Model monitoring metrics
from prometheus_client import Counter, Histogram, Gauge

# Track predictions
prediction_counter = Counter(
    'model_predictions_total',
    'Total number of predictions',
    ['model_version', 'prediction_class']
)

# Track latency
prediction_latency = Histogram(
    'model_prediction_latency_seconds',
    'Time spent processing prediction',
    buckets=[0.01, 0.05, 0.1, 0.5, 1.0]
)

# Track data drift
data_drift_score = Gauge(
    'model_data_drift_score',
    'Current data drift score',
    ['feature_name']
)

5. Colaboración

MLOps permite la colaboración entre equipos multifuncionales:

Rol	Responsabilidad
Científicos de Datos	Desarrollo de modelos, experimentación
Ingenieros de ML	Desarrollo y optimización de pipelines
Ingenieros DevOps	Infraestructura, CI/CD
Ingenieros de Datos	Pipelines de datos, calidad
Product Managers	Requisitos, definición de métricas

Niveles de madurez de MLOps

Las organizaciones evolucionan a través de niveles de madurez en MLOps:

Nivel 0: Proceso manual

┌─────────────────────────────────────────────────────────┐
│                    LEVEL 0: MANUAL                       │
├─────────────────────────────────────────────────────────┤
│ • Jupyter notebooks para todo                            │
│ • Despliegue manual de modelos                           │
│ • Sin versionado                                         │
│ • Sin monitoreo                                          │
│ • Los científicos de datos hacen todo                    │
└─────────────────────────────────────────────────────────┘

Características:

• Scripts y notebooks
• Despliegues manuales dirigidos por scripts
• Falta de integración continua
• Lanzamientos poco frecuentes (trimestrales o menos)

Nivel 1: Automatización de pipelines de ML

┌─────────────────────────────────────────────────────────┐
│              LEVEL 1: PIPELINE AUTOMATION                │
├─────────────────────────────────────────────────────────┤
│ • Pipeline de entrenamiento automatizado                 │
│ • Seguimiento de experimentos                            │
│ • Registro de modelos                                    │
│ • Monitoreo básico                                       │
│ • El reentrenamiento requiere activación manual          │
└─────────────────────────────────────────────────────────┘

Características:

• Pipelines de entrenamiento reproducibles
• Seguimiento de experimentos con MLflow/W&B
• Versionado de modelos
• Los disparadores de despliegue siguen siendo manuales

Nivel 2: Automatización de pipelines CI/CD

┌─────────────────────────────────────────────────────────┐
│                 LEVEL 2: CI/CD AUTOMATION                │
├─────────────────────────────────────────────────────────┤
│ • CI/CD automatizado para ML                             │
│ • Pruebas automatizadas (datos, modelo, integración)     │
│ • Despliegue automatizado                                │
│ • Monitoreo integral                                     │
│ • Disparadores automáticos de reentrenamiento            │
└─────────────────────────────────────────────────────────┘

Características:

• Automatización completa de CI/CD
• Pruebas A/B y despliegues canarios
• Reversiones automáticas
• Detección de deriva de datos y modelos

El stack de MLOps

Un stack típico de MLOps incluye:

Ejemplo práctico: configuración simple de MLOps

Aquí tiene una configuración mínima de MLOps usando herramientas populares:

# train.py - Example training script with MLflow tracking
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score
import pandas as pd

# Enable autologging
mlflow.sklearn.autolog()

def train_model():
    # Load data
    df = pd.read_csv("data/training_data.csv")
    X = df.drop("target", axis=1)
    y = df["target"]
    
    # Split data
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42
    )
    
    with mlflow.start_run():
        # Log parameters
        mlflow.log_param("model_type", "RandomForest")
        mlflow.log_param("n_estimators", 100)
        
        # Train model
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X_train, y_train)
        
        # Evaluate
        predictions = model.predict(X_test)
        accuracy = accuracy_score(y_test, predictions)
        f1 = f1_score(y_test, predictions, average='weighted')
        
        # Log metrics
        mlflow.log_metric("accuracy", accuracy)
        mlflow.log_metric("f1_score", f1)
        
        # Log model
        mlflow.sklearn.log_model(model, "model")
        
        print(f"Model trained with accuracy: {accuracy:.4f}")

if __name__ == "__main__":
    train_model()

Puntos clave

Summary

1. MLOps cierra la brecha entre el desarrollo de ML y las operaciones
2. La automatización es esencial para sistemas de ML confiables y escalables
3. Versione todo: código, datos, modelos y configuraciones
4. Monitoree continuamente: los modelos se degradan silenciosamente sin el monitoreo adecuado
5. Colabore eficazmente: MLOps requiere equipos multifuncionales

Lecturas recomendadas

• MLOps de Google: Entrega continua para aprendizaje automático
• Modelo de madurez de MLOps de Microsoft
• Deuda técnica oculta en sistemas de ML

---

Siguiente: Capítulo 2: MLOps vs DevOps vs DataOps