Capítulo 1: Introdução ao MLflow

O que é MLflow?

MLflow é uma plataforma open source para gerenciar o ciclo de vida completo de machine learning. Ela oferece quatro componentes principais:

Configurando o MLflow

Instalação

# Instalação básica
pip install mlflow

# Com extras
pip install mlflow[extras]

# Iniciar servidor local de tracking
mlflow server --host 0.0.0.0 --port 5000

Configuração para Produção

# docker-compose.yml
version: '3.8'
services:
  mlflow:
    image: ghcr.io/mlflow/mlflow:v2.10.0
    ports:
      - "5000:5000"
    environment:
      - MLFLOW_BACKEND_STORE_URI=postgresql://user:pass@postgres:5432/mlflow
      - MLFLOW_DEFAULT_ARTIFACT_ROOT=s3://mlflow-artifacts/
      - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
      - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
    command: >
      mlflow server
      --backend-store-uri postgresql://user:pass@postgres:5432/mlflow
      --default-artifact-root s3://mlflow-artifacts/
      --host 0.0.0.0
      --port 5000
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mlflow
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

MLflow Tracking

Rastreamento Básico de Experimentos

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score

# Definir URI de tracking
mlflow.set_tracking_uri("http://localhost:5000")

# Definir experimento
mlflow.set_experiment("customer-churn-prediction")

# Iniciar uma execução
with mlflow.start_run(run_name="random-forest-baseline"):
    # Log de parâmetros
    n_estimators = 100
    max_depth = 10
    mlflow.log_param("n_estimators", n_estimators)
    mlflow.log_param("max_depth", max_depth)
    mlflow.log_param("model_type", "RandomForest")
    
    # Treinar modelo
    model = RandomForestClassifier(
        n_estimators=n_estimators,
        max_depth=max_depth,
        random_state=42
    )
    model.fit(X_train, y_train)
    
    # Fazer previsões
    predictions = model.predict(X_test)
    probabilities = model.predict_proba(X_test)[:, 1]
    
    # Log de métricas
    mlflow.log_metric("accuracy", accuracy_score(y_test, predictions))
    mlflow.log_metric("f1_score", f1_score(y_test, predictions))
    mlflow.log_metric("auc_roc", roc_auc_score(y_test, probabilities))
    
    # Log do modelo
    mlflow.sklearn.log_model(model, "model")
    
    # Log de artefatos (arquivos)
    mlflow.log_artifact("feature_importance.csv")

Autologging

# Habilitar autolog para sklearn
mlflow.sklearn.autolog()

# Agora o treinamento faz log automático de tudo
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)
# Parâmetros, métricas e modelo são registrados automaticamente!

# Autolog para outros frameworks
mlflow.pytorch.autolog()
mlflow.tensorflow.autolog()
mlflow.xgboost.autolog()
mlflow.lightgbm.autolog()

Execuções Aninhadas para Tuning de Hiperparâmetros

from sklearn.model_selection import ParameterGrid

param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10]
}

with mlflow.start_run(run_name="hyperparameter-search"):
    best_auc = 0
    best_params = None
    
    for params in ParameterGrid(param_grid):
        with mlflow.start_run(nested=True):
            # Log de parâmetros
            mlflow.log_params(params)
            
            # Treinar modelo
            model = RandomForestClassifier(**params, random_state=42)
            model.fit(X_train, y_train)
            
            # Avaliar
            auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1])
            mlflow.log_metric("auc_roc", auc)
            
            # Rastrear o melhor
            if auc > best_auc:
                best_auc = auc
                best_params = params
    
    # Log dos melhores resultados na execução pai
    mlflow.log_params({f"best_{k}": v for k, v in best_params.items()})
    mlflow.log_metric("best_auc_roc", best_auc)

MLflow Projects

Estrutura do Projeto

ml-project/
├── MLproject          # Definição do projeto
├── conda.yaml         # Especificação do ambiente
├── train.py           # Script de treinamento
└── requirements.txt   # Alternativa ao conda

Arquivo MLproject

# MLproject
name: customer-churn-model

conda_env: conda.yaml

entry_points:
  main:
    parameters:
      n_estimators: {type: int, default: 100}
      max_depth: {type: int, default: 10}
      data_path: {type: string, default: "data/processed/"}
    command: "python train.py --n-estimators {n_estimators} --max-depth {max_depth} --data-path {data_path}"
  
  evaluate:
    parameters:
      model_path: string
      test_data: string
    command: "python evaluate.py --model-path {model_path} --test-data {test_data}"

Executando Projetos

# Executar localmente
mlflow run . -P n_estimators=200 -P max_depth=15

# Executar a partir do Git
mlflow run https://github.com/company/ml-project -P n_estimators=200

# Executar com ambiente específico
mlflow run . --env-manager conda

MLflow Models

Assinatura do Modelo e Exemplo de Entrada

from mlflow.models.signature import infer_signature
import pandas as pd

# Inferir assinatura a partir dos dados
signature = infer_signature(X_train, model.predict(X_train))

# Criar exemplo de entrada
input_example = X_train.head(5)

# Logar modelo com assinatura
mlflow.sklearn.log_model(
    model,
    "model",
    signature=signature,
    input_example=input_example,
    registered_model_name="customer-churn-model"
)

Sabores de Modelo

# Diferentes formas de registrar modelos

# Sklearn
mlflow.sklearn.log_model(sklearn_model, "model")

# PyTorch
mlflow.pytorch.log_model(pytorch_model, "model")

# TensorFlow/Keras
mlflow.tensorflow.log_model(tf_model, "model")

# Modelos customizados com pyfunc
class CustomModel(mlflow.pyfunc.PythonModel):
    def load_context(self, context):
        # Carregar artefatos
        self.model = load_model(context.artifacts["model_path"])
    
    def predict(self, context, model_input):
        return self.model.predict(model_input)

mlflow.pyfunc.log_model(
    "model",
    python_model=CustomModel(),
    artifacts={"model_path": "path/to/model"}
)

Principais Pontos

Summary

1. MLflow Tracking registra parâmetros, métricas e artefatos
2. Autologging simplifica o rastreamento para frameworks suportados
3. MLflow Projects garantem código de ML reprodutível
4. MLflow Models fornecem empacotamento padrão para deploy
5. Assinaturas de modelo definem entradas e saídas esperadas

---

Próximo: Capítulo 2: Weights and Biases