Pular para o conteúdo principal

Capítulo 1: O que é MLOps?

Introdução​

MLOps (Machine Learning Operations) é um conjunto de práticas que visa implantar e manter modelos de machine learning em produção de forma confiável e eficiente. Ele combina Machine Learning, DevOps e Engenharia de Dados para automatizar e padronizar o ciclo de vida de ML.

Definition

MLOps = Machine Learning + DevOps + Engenharia de Dados

É a disciplina de entregar sistemas de ML com o mesmo rigor e confiabilidade dos sistemas tradicionais de software.

O Problema que o MLOps Resolve​

O Desafio do Desenvolvimento de ML​

O desenvolvimento tradicional de software segue um caminho bem definido:

Code → Build → Test → Deploy → Monitor

O machine learning adiciona uma complexidade significativa:

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

Por que 87% dos Projetos de ML Nunca Chegam à Produção​

De acordo com pesquisas do setor:

DesafioImpacto
Baixa reprodutibilidade do modeloNão é possível recriar resultados
Falta de versionamentoDrift de código, dados e modelo
Deploy manualReleases lentos e propensos a erros
Sem monitoramentoFalhas silenciosas de modelo
Dívida técnicaSistemas não sustentáveis

Princípios Fundamentais do MLOps​

1. Automação​

Tudo o que puder ser automatizado, deve 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. Versionamento de Tudo​

Acompanhe todos os componentes do seu 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. Integração Contínua/Deploy Contínuo (CI/CD)​

4. Monitoramento e Observabilidade​

Modelos em produção exigem monitoramento 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. Colaboração​

O MLOps possibilita a colaboração entre equipes multidisciplinares:

PapelResponsabilidade
Cientistas de DadosDesenvolvimento de modelos, experimentação
Engenheiros de MLDesenvolvimento e otimização de pipelines
Engenheiros de DevOpsInfraestrutura, CI/CD
Engenheiros de DadosPipelines de dados, qualidade
Product ManagersRequisitos, definição de métricas

Níveis de Maturidade do MLOps​

As organizações evoluem através dos níveis de maturidade do MLOps:

Nível 0: Processo Manual​

┌─────────────────────────────────────────────────────────┐
│                    LEVEL 0: MANUAL                       │
├─────────────────────────────────────────────────────────┤
│ • Jupyter notebooks for everything                       │
│ • Manual model deployment                                │
│ • No versioning                                          │
│ • No monitoring                                          │
│ • Data scientists do everything                          │
└─────────────────────────────────────────────────────────┘

Características:

  • Scripts e notebooks
  • Deploys manuais, baseados em scripts
  • Ausência de integração contínua
  • Releases raros (trimestrais ou menos)

Nível 1: Automação de Pipeline de ML​

┌─────────────────────────────────────────────────────────┐
│              LEVEL 1: PIPELINE AUTOMATION                │
├─────────────────────────────────────────────────────────┤
│ • Automated training pipeline                            │
│ • Experiment tracking                                    │
│ • Model registry                                         │
│ • Basic monitoring                                       │
│ • Retraining requires manual trigger                     │
└─────────────────────────────────────────────────────────┘

Características:

  • Pipelines de treinamento reprodutíveis
  • Rastreamento de experimentos com MLflow/W&B
  • Versionamento de modelos
  • Deploy ainda com gatilhos manuais

Nível 2: Automação de Pipeline CI/CD​

┌─────────────────────────────────────────────────────────┐
│                 LEVEL 2: CI/CD AUTOMATION                │
├─────────────────────────────────────────────────────────┤
│ • Automated CI/CD for ML                                 │
│ • Automated testing (data, model, integration)           │
│ • Automated deployment                                   │
│ • Comprehensive monitoring                               │
│ • Automatic retraining triggers                          │
└─────────────────────────────────────────────────────────┘

Características:

  • Automação completa de CI/CD
  • Testes A/B e deploys canário
  • Rollbacks automáticos
  • Detecção de drift de dados e modelos

A Stack de MLOps​

Uma stack típica de MLOps inclui:

Exemplo Prático: Setup Simples de MLOps​

Veja um setup mínimo de MLOps usando ferramentas 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()

Principais Aprendizados​

Summary
  1. MLOps preenche a lacuna entre o desenvolvimento de ML e as operações
  2. Automação é essencial para sistemas de ML confiáveis e escaláveis
  3. Versione tudo – código, dados, modelos e configurações
  4. Monitore continuamente – modelos degradam silenciosamente sem monitoramento adequado
  5. Colabore de forma efetiva – MLOps exige equipes multidisciplinares

Leituras Complementares​

Próximo: Capítulo 2: MLOps vs DevOps vs DataOps