Machine Learning: Primeiros Passos com MLOps e MLflow

Q: P: Como implanto um MLflow Tracking Server?

R: Para desenvolvimento local, use mlflow server --backend-store-uri sqlite:///mlflow.db. Para produção, use PostgreSQL + armazenamento de objetos (S3/GCS) + um reverse proxy.

Última atualização: 2026-08-26

ML sem gerenciamento de experimentos é como código sem Git — ninguém sabe qual versão é a melhor.

1. O que você vai aprender

Conceitos de MLOps: DevOps estendido para ML, gerenciando o ciclo de vida completo de ML
Os quatro componentes centrais do MLflow: Tracking / Projects / Models / Model Registry
Rastreamento de experimentos na prática: log de parâmetros, métricas, modelos e gráficos; comparação de versões de modelos
Model Registry: gerenciamento dos estágios do modelo (Staging → Production), rollback de versão
O gerenciamento de experimentos do Bob: como gerenciar sistematicamente 50+ experimentos para o SalesPredict

2. A história real de um líder de equipe de ML

(1) O problema: 50 experimentos depois, sem ideia de qual modelo é o melhor

Bob rodou 50+ experimentos em três semanas — diferentes algoritmos, diferentes features, diferentes hiperparâmetros. Os parâmetros e resultados de cada experimento estavam espalhados por Jupyter Notebooks, mensagens no Slack e post-its. Quando o gerente de produto perguntou: "Qual modelo é o melhor agora?", Bob gastou duas horas fuçando registros e ainda não tinha certeza. O caos de experimentos é a norma em projetos de ML.

(2) A solução com MLflow

O MLflow registra automaticamente os parâmetros, métricas, modelos e gráficos de cada experimento. Todos os experimentos são centralizados, comparáveis e rastreáveis.

PYTHON

import mlflow

mlflow.set_experiment("SalesPredict-Revenue")
with mlflow.start_run(run_name="xgboost_v1"):
    mlflow.log_params({"n_estimators": 300, "max_depth": 6, "learning_rate": 0.1})
    mlflow.log_metrics({"r2": 0.89, "mae": 8.5})
    mlflow.sklearn.log_model(model, "model")

(3) O resultado: encontre o melhor experimento em 2 segundos, eficiência 3x

Depois de adotar o MLflow, Bob consegue encontrar o melhor modelo histórico em 2 segundos. Novos experimentos são automaticamente comparados com runs passadas, e a eficiência de colaboração da equipe triplicou.

3. Conceitos de MLOps

(1) Gerenciamento do ciclo de vida de ML

MLOps é DevOps estendido para o domínio de ML — não se importa apenas com versões de código, mas também com versões de dados, versões de experimentos e versões de modelos.

graph TB
    DATA[Engenharia de Dados<br/>Versão e Pipeline] --> EXP[Experimento<br/>Rastrear e Comparar]
    EXP --> REG[Model Registry<br/>Versão e Estágio]
    REG --> DEPLOY[Implantação<br/>Servir e Escalar]
    DEPLOY --> MON[Monitoramento<br/>Drift e Desempenho]
    MON -->|Gatilho de Re-treino| DATA

(2) Como ML difere da engenharia de software tradicional

Dimensão	Engenharia de Software	Engenharia de ML
Controle de versão	Código	Código + dados + modelos
Testes	Testes unitários	Testes de dados + testes de modelo
Implantação	Implantar uma vez	Re-treinamento contínuo
Causa de degradação	Bugs	Drift de dados / drift de conceito
Reprodutibilidade	Código = resultado	Código + dados + params = resultado

4. Os quatro componentes centrais do MLflow

(1) MLflow Tracking

▶ Exemplo: Registrando parâmetros e métricas de experimento

PYTHON

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import r2_score, mean_absolute_error
from sklearn.model_selection import train_test_split
import numpy as np

mlflow.set_tracking_uri("sqlite:///mlflow.db")
mlflow.set_experiment("SalesPredict-Revenue")

rng = np.random.default_rng(42)
n = 1000
X = rng.uniform(0, 100, (n, 5))
y = 50 + 0.8 * X[:, 0] + 1.2 * X[:, 1] + rng.normal(0, 5, n)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Experimento 1: Random Forest
with mlflow.start_run(run_name="rf_baseline"):
    params = {"n_estimators": 100, "max_depth": 10}
    mlflow.log_params(params)

    model = RandomForestRegressor(**params, random_state=42)
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    r2 = r2_score(y_test, y_pred)
    mae = mean_absolute_error(y_test, y_pred)
    mlflow.log_metrics({"r2": r2, "mae": mae})
    mlflow.sklearn.log_model(model, "model")

    print(f"RF: R²={r2:.4f}, MAE={mae:.2f}")

# Experimento 2: XGBoost
import xgboost as xgb

with mlflow.start_run(run_name="xgboost_v1"):
    params = {"n_estimators": 300, "max_depth": 6, "learning_rate": 0.1}
    mlflow.log_params(params)

    model = xgb.XGBRegressor(**params, random_state=42)
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    r2 = r2_score(y_test, y_pred)
    mae = mean_absolute_error(y_test, y_pred)
    mlflow.log_metrics({"r2": r2, "mae": mae})
    mlflow.xgboost.log_model(model, "model")

    print(f"XGB: R²={r2:.4f}, MAE={mae:.2f}")

Saída:

TEXT 📖 Somente leitura

# Execução bem-sucedida

▶ Exemplo: Consultando e comparando experimentos

PYTHON

import mlflow

# Consultar experimentos
experiment = mlflow.get_experiment_by_name("SalesPredict-Revenue")
runs = mlflow.search_runs(experiment_ids=[experiment.experiment_id])

# Ordenar por R² (melhor primeiro)
best_runs = runs.sort_values("metrics.r2", ascending=False)
print("Top 3 runs por R²:")
print(best_runs[["run_name", "metrics.r2", "metrics.mae",
                   "params.n_estimators", "params.max_depth"]].head(3))

Saída:

TEXT 📖 Somente leitura

Top 3 runs por R²:

(2) MLflow Models e Registry

▶ Exemplo: Registro de modelo e gerenciamento de estágio

PYTHON

import mlflow

# Registrar um modelo
model_uri = f"runs:/{run_id}/model"
mlflow.register_model(model_uri, "SalesPredict-Revenue-Model")

# Transição de estágio do modelo
client = mlflow.tracking.MlflowClient()
client.transition_model_version_stage(
    name="SalesPredict-Revenue-Model",
    version=1,
    stage="Staging",
)

# Promover para produção
client.transition_model_version_stage(
    name="SalesPredict-Revenue-Model",
    version=1,
    stage="Production",
)

# Carregar modelo de produção
model = mlflow.sklearn.load_model("models:/SalesPredict-Revenue-Model/Production")

Saída:

TEXT 📖 Somente leitura

# Execução bem-sucedida

Estágio do Registry	Significado	Ação típica
None	Acabou de ser registrado	Testes automatizados
Staging	Aguardando validação	Teste A/B
Production	Ativo em produção	Serviço online
Archived	Aposentado	Manutenção de registros

5. MLflow Projects e Log Automático

▶ Exemplo: Log automático com autolog

PYTHON

import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
import numpy as np

# Auto-log: registra automaticamente todos os parâmetros, métricas e o modelo
mlflow.sklearn.autolog()

rng = np.random.default_rng(42)
X = rng.uniform(0, 100, (1000, 5))
y = 50 + 0.8 * X[:, 0] + rng.normal(0, 5, n)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

with mlflow.start_run(run_name="gb_autolog"):
    model = GradientBoostingRegressor(n_estimators=100, max_depth=5, learning_rate=0.1, random_state=42)
    model.fit(X_train, y_train)
    # autolog captura tudo automaticamente!

Saída:

TEXT 📖 Somente leitura

# Execução bem-sucedida

Framework autolog	O que é registrado automaticamente
sklearn	Parâmetros, métricas, modelo, matriz de confusão
xgboost	Parâmetros, métricas, importância de features
lightgbm	Parâmetros, métricas, importância de features
pytorch	Parâmetros, métricas, modelo

▶ Exemplo: Registrando gráficos personalizados

PYTHON

import mlflow
import matplotlib.pyplot as plt
import numpy as np

with mlflow.start_run(run_name="feature_analysis"):
    # Criar e registrar um gráfico
    fig, ax = plt.subplots()
    ax.barh(["feat_1", "feat_2", "feat_3", "feat_4", "feat_5"],
            [0.35, 0.25, 0.15, 0.10, 0.05])
    ax.set_xlabel("Importância")
    ax.set_title("Importância das Features")
    plt.tight_layout()

    mlflow.log_figure(fig, "feature_importance.png")
    plt.close()

    # Registrar artefatos (qualquer arquivo)
    # mlflow.log_artifact("local_file.csv")

Saída:

TEXT 📖 Somente leitura

# Execução bem-sucedida

6. O gerenciamento de 50+ experimentos do Bob na prática

▶ Exemplo: Framework de rastreamento de experimentos em lote

PYTHON

import mlflow
import mlflow.sklearn
import xgboost as xgb
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.model_selection import cross_val_score
from sklearn.metrics import r2_score, mean_absolute_error
import numpy as np

mlflow.set_experiment("SalesPredict-Benchmark")

# Dados simulados
rng = np.random.default_rng(42)
X = rng.uniform(0, 100, (2000, 10))
y = 50 + X[:, :5] @ [0.8, 1.2, -0.5, 0.3, 0.1] + rng.normal(0, 5, 2000)

# Rastreamento sistemático de experimentos
experiments = [
    {"name": "linear_baseline", "model": LinearRegression(), "params": {}},
    {"name": "ridge_alpha1", "model": Ridge(alpha=1), "params": {"alpha": 1}},
    {"name": "rf_100", "model": RandomForestRegressor(n_estimators=100, random_state=42),
     "params": {"n_estimators": 100}},
    {"name": "rf_300", "model": RandomForestRegressor(n_estimators=300, random_state=42),
     "params": {"n_estimators": 300}},
    {"name": "xgb_d6_lr01", "model": xgb.XGBRegressor(max_depth=6, learning_rate=0.1, random_state=42),
     "params": {"max_depth": 6, "learning_rate": 0.1}},
]

for exp in experiments:
    with mlflow.start_run(run_name=exp["name"]):
        mlflow.log_params(exp["params"])
        cv_scores = cross_val_score(exp["model"], X, y, cv=5, scoring="r2")
        mlflow.log_metrics({
            "cv_r2_mean": cv_scores.mean(),
            "cv_r2_std": cv_scores.std(),
        })

# Encontrar o melhor experimento
runs = mlflow.search_runs(
    experiment_ids=[mlflow.get_experiment_by_name("SalesPredict-Benchmark").experiment_id],
    order_by=["metrics.cv_r2_mean DESC"],
)
print("Melhores experimentos:")
print(runs[["run_name", "metrics.cv_r2_mean", "metrics.cv_r2_std"]].head(5))

Saída:

TEXT 📖 Somente leitura

Melhores experimentos:

❓ Perguntas Frequentes

P: Devo usar MLflow ou Weights & Biases (W&B)? R: MLflow é open-source, gratuito, auto-hospedável e completo em recursos. W&B oferece melhores visualizações e colaboração em equipe mais fácil, mas tem licença comercial. Para indivíduos ou equipes pequenas, vá com MLflow; para equipes grandes, W&B é uma ótima opção.

P: Como implanto um MLflow Tracking Server? R: Para desenvolvimento local, use mlflow server --backend-store-uri sqlite:///mlflow.db. Para produção, use PostgreSQL + armazenamento de objetos (S3/GCS) + um reverse proxy.

P: Posso misturar autolog com log manual? R: Sim. O autolog captura informações padrão, enquanto o log manual complementa com conteúdo personalizado (por exemplo, métricas de negócio, gráficos). Abordagem recomendada: dependa do autolog como linha de base e adicione logs manuais para extras.

P: O Model Registry é realmente necessário? R: Com certeza. Sem um Registry, os arquivos de modelo ficam espalhados por toda parte, e você não tem ideia de qual está em produção ou qual está desatualizado. O Registry fornece gerenciamento de versão, gerenciamento de estágio e capacidades de rollback.

P: Como organizo um grande número de experimentos? R: Use experiments para agrupamento (por exemplo, SalesPredict-Revenue / SalesPredict-Churn), tags para rotulagem (por exemplo, team=bob, priority=high) e run_name para distinção (por exemplo, xgboost_v3_tuned).

P: Como garantir a reprodutibilidade dos experimentos? R: MLflow registra parâmetros + versão do código + versão dos dados + semente aleatória. Use mlflow.sklearn.load_model(run_id) para restaurar o modelo completo. Combine com DVC para gerenciamento de versão de dados.

📖 Resumo

MLOps = DevOps para ML: gerenciando o ciclo de vida completo de versões de dados, versões de experimentos e versões de modelos
Os quatro componentes centrais do MLflow: Tracking (registro) + Projects (empacotamento) + Models (formato) + Registry (registro)
Essentials do Tracking: log_params + log_metrics + log_model — cada experimento registrado automaticamente
O Model Registry gerencia os estágios do modelo: None → Staging → Production → Archived
O autolog captura automaticamente parâmetros, métricas e modelos, reduzindo o trabalho manual de registro
Reprodutibilidade = registrar parâmetros + dados + semente aleatória + versão do código por completo

📝 Exercícios

Básico (Dificuldade ⭐): Instale o MLflow, inicie um Tracking Server local e registre um experimento com um parâmetro (lr=0.01) e uma métrica (r2=0.85). Dica: pip install mlflow + mlflow.start_run().
Intermediário (Dificuldade ⭐⭐): Use o autolog para registrar o processo de treinamento do RandomForestRegressor do sklearn, depois consulte todas as runs e ordene por R². Dica: mlflow.sklearn.autolog() + search_runs().
Desafio (Dificuldade ⭐⭐⭐): Implemente o framework de gerenciamento de experimentos do Bob — execute 5 modelos nos dados do SalesPredict, registre automaticamente parâmetros/métricas/modelos no MLflow para cada run, registre o melhor modelo no Registry e carregue o modelo de Production para previsão. Dica: consulte o exemplo de experimentos em lote na Seção 6.

← Anterior: Avaliação e Ajuste de Modelos | Próximo: Implantação de Modelos →

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós