Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos
Os alunos instrumentarão um script de treinamento com mlflow.log_param e mlflow.log_metric, iniciarão a interface do MLflow e compararão execuções com diferentes configurações de hiperparâmetros.
Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos é uma aula grátis de Machine Learning Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Machine Learning Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Machine Learning Academy inclui 4 aulas no total.
Por que o acompanhamento de experimentos é importante
Quando você treina vários modelos com hiperparâmetros diferentes, é fácil perder o controle de qual execução alcançou o melhor resultado. O acompanhamento de experimentos registra automaticamente os parâmetros, as métricas e a versão do código de cada execução de treinamento em um banco de dados pesquisável. Sem isso, as equipes acabam recorrendo a planilhas desorganizadas ou simplesmente esquecendo o que funcionou. O MLflow é a ferramenta de código aberto padrão do setor para acompanhar experimentos de ML e gerenciar o ciclo de vida dos modelos.
Instalando e iniciando o MLflow
O MLflow é um pacote totalmente escrito em Python que não exige um banco de dados externo para começar — ele armazena as execuções localmente em um diretório mlruns/. Instale-o com pip e inicie a interface de acompanhamento para visualizar as execuções em um navegador. A interface mostra todos os experimentos, os parâmetros e as métricas de cada execução e permite comparar execuções lado a lado com gráficos interativos.
# Install MLflow
# pip install mlflow scikit-learn
import mlflow
import mlflow.sklearn
# Start the tracking UI (run this in a terminal):
# mlflow ui --host 0.0.0.0 --port 5000
# Then open http://localhost:5000
# Check MLflow version
print('MLflow version:', mlflow.__version__)
# Default tracking URI stores to ./mlruns
print('Tracking URI:', mlflow.get_tracking_uri())Criando experimentos
O MLflow organiza as execuções em experimentos — agrupamentos lógicos de execuções relacionadas. Crie um experimento nomeado com mlflow.set_experiment. Todas as execuções subsequentes pertencerão a esse experimento. Use nomes descritivos que identifiquem o projeto e a data, por exemplo, 'random_forest_imdb_2024'. Cada execução dentro de um experimento recebe um ID exclusivo, um nome legível e seu próprio armazenamento de parâmetros, métricas e artefatos.
import mlflow
# Create or switch to an experiment
experiment_name = 'sentiment_classification'
mlflow.set_experiment(experiment_name)
# List all experiments
for exp in mlflow.search_experiments():
print(f'ID: {exp.experiment_id} Name: {exp.name}')
# Get current experiment info
experiment = mlflow.get_experiment_by_name(experiment_name)
print('Artifact location:', experiment.artifact_location)Registrando parâmetros com mlflow.log_param
Parâmetros são as escolhas de configuração feitas antes do início do treinamento: hiperparâmetros como taxa de aprendizado, número de estimadores e intensidade da regularização. Registre-os com mlflow.log_param(key, value) dentro do contexto de uma execução ativa. Os parâmetros são imutáveis depois de registrados — eles definem a configuração do experimento e ajudam você a filtrar as execuções para encontrar a configuração que funcionou melhor.
import mlflow
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
with mlflow.start_run(run_name='rf_baseline'):
n_estimators = 100
max_depth = 5
mlflow.log_param('n_estimators', n_estimators)
mlflow.log_param('max_depth', max_depth)
mlflow.log_param('random_state', 42)
clf = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=42)
clf.fit(X_train, y_train)
print('Params logged.')Registrando métricas com mlflow.log_metric
Métricas são os resultados quantitativos produzidos durante e após o treinamento: precisão, F1 e valores de perda. Registre-as com mlflow.log_metric(key, value) ou mlflow.log_metric(key, value, step=i) para acompanhar o progresso ao longo das épocas. Registrar métricas a cada época permite que o MLflow trace curvas de aprendizado na interface, facilitando a comparação da velocidade de convergência entre as execuções.
import mlflow
from sklearn.metrics import accuracy_score, f1_score
with mlflow.start_run(run_name='rf_run_1'):
mlflow.log_param('n_estimators', 100)
mlflow.log_param('max_depth', 5)
# Train model (abbreviated)
clf = RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42)
clf.fit(X_train, y_train)
preds = clf.predict(X_test)
acc = accuracy_score(y_test, preds)
f1 = f1_score(y_test, preds)
mlflow.log_metric('test_accuracy', acc)
mlflow.log_metric('test_f1', f1)
print(f'Logged accuracy={acc:.4f}, f1={f1:.4f}')Registrando artefatos
Artefatos são arquivos associados a uma execução: pesos do modelo treinado, gráficos, matrizes de confusão ou gráficos de importância das características. Registre-os com mlflow.log_artifact(local_path). O MLflow armazena o arquivo no diretório de artefatos da execução e permite baixá-lo pela interface. Registrar a imagem da matriz de confusão junto com as métricas oferece aos revisores uma visão completa sem que precisem analisar o código.
import mlflow
import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay
import numpy as np
with mlflow.start_run():
clf.fit(X_train, y_train)
preds = clf.predict(X_test)
# Save confusion matrix as an artifact
fig, ax = plt.subplots(figsize=(5, 4))
ConfusionMatrixDisplay.from_predictions(y_test, preds, ax=ax)
plt.tight_layout()
plt.savefig('/tmp/confusion_matrix.png')
plt.close()
mlflow.log_artifact('/tmp/confusion_matrix.png')
print('Artifact logged.')Registro automático com mlflow.sklearn.autolog
Para o scikit-learn, o MLflow oferece o registro automático, que captura automaticamente todos os parâmetros, as métricas e o modelo treinado, sem nenhuma chamada manual de registro. Basta chamar mlflow.sklearn.autolog() antes do treinamento. O registro automático também é compatível com XGBoost, LightGBM, PyTorch, TensorFlow e outros, com uma ativação semelhante de uma única linha. É a maneira mais rápida de começar a acompanhar os experimentos sem modificar o código de treinamento existente.
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
# Enable auto-logging -- no manual log calls needed
mlflow.sklearn.autolog()
with mlflow.start_run(run_name='gb_autolog'):
clf = GradientBoostingClassifier(n_estimators=200, max_depth=3, learning_rate=0.05)
clf.fit(X_train, y_train)
# MLflow automatically logs:
# - All constructor params
# - Training accuracy
# - Model artifact
print('Auto-logged run complete.')Comparando execuções na interface do MLflow
Depois de realizar várias execuções com diferentes hiperparâmetros, abra a interface do MLflow em http://localhost:5000. Selecione várias execuções usando as caixas de seleção e clique em Comparar para visualizá-las lado a lado. A página de comparação exibe um gráfico de coordenadas paralelas em que cada eixo representa um parâmetro ou uma métrica, facilitando identificar qual combinação de parâmetros levou à maior precisão. Também é possível ordenar a tabela de execuções por qualquer coluna de métricas.
import mlflow
# Search runs programmatically (useful in CI/CD pipelines)
runs = mlflow.search_runs(
experiment_names=['sentiment_classification'],
order_by=['metrics.test_accuracy DESC']
)
if not runs.empty:
best_run = runs.iloc[0]
print('Best run ID:', best_run['run_id'])
print('Best accuracy:', best_run['metrics.test_accuracy'])
print('n_estimators:', best_run['params.n_estimators'])
print('max_depth:', best_run['params.max_depth'])Registrando modelos com mlflow.sklearn.log_model
Além de registrar arquivos de modelo como artefatos genéricos, use mlflow.sklearn.log_model para registrar o modelo no formato padronizado do MLflow. Esse formato inclui o objeto do modelo, os metadados da sua variante e um arquivo de configuração MLmodel gerado automaticamente. O formato padronizado permite a implantação com um clique em servidores REST locais (mlflow models serve) e em plataformas de nuvem, como Azure ML e AWS SageMaker.
import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
with mlflow.start_run(run_name='rf_logged_model'):
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
mlflow.log_metric('accuracy', accuracy_score(y_test, clf.predict(X_test)))
# Log in sklearn flavour -- enables mlflow models serve
mlflow.sklearn.log_model(
sk_model=clf,
artifact_path='random_forest',
registered_model_name='SentimentRF'
)
print('Model registered in Model Registry.')Adicionando etiquetas às execuções para organização
As execuções do MLflow podem ter etiquetas: metadados de chave e valor que vão além dos parâmetros e das métricas estruturados. Use etiquetas para armazenar a versão do conjunto de dados, o hash do commit do código, o nome da pessoa responsável pelo experimento ou observações sobre o que mudou. As etiquetas podem ser pesquisadas e filtradas na interface. Uma boa convenção de etiquetagem — como sempre registrar dataset_version e git_sha — garante que cada execução seja reproduzível e auditável mesmo meses depois.
import mlflow
import subprocess
def get_git_sha():
try:
return subprocess.check_output(
['git', 'rev-parse', 'HEAD'], text=True
).strip()
except Exception:
return 'unknown'
with mlflow.start_run():
mlflow.set_tag('dataset_version', 'imdb_v2')
mlflow.set_tag('git_sha', get_git_sha())
mlflow.set_tag('author', 'mehmet.canker')
mlflow.set_tag('notes', 'Testing higher max_depth after previous plateau')
mlflow.log_param('max_depth', 8)
print('Run tagged.')Configuração de um servidor remoto de acompanhamento
Para colaborar em equipe, direcione o MLflow para um servidor remoto de acompanhamento em vez da pasta local mlruns/. Defina o URI de acompanhamento como a URL do seu servidor antes de fazer qualquer chamada ao MLflow. Todas as pessoas da equipe registram dados no mesmo servidor, veem as execuções umas das outras e acessam artefatos compartilhados. O back-end do servidor pode usar um banco de dados PostgreSQL para os metadados e S3/GCS para o armazenamento de artefatos, oferecendo durabilidade e controle de acesso de nível empresarial.
import mlflow
import os
# Point to a remote MLflow tracking server
os.environ['MLFLOW_TRACKING_URI'] = 'http://mlflow.yourcompany.com:5000'
os.environ['MLFLOW_TRACKING_USERNAME'] = 'data_team'
os.environ['MLFLOW_TRACKING_PASSWORD'] = 'secret'
mlflow.set_tracking_uri(os.environ['MLFLOW_TRACKING_URI'])
# All subsequent mlflow calls go to the remote server
mlflow.set_experiment('shared_team_experiment')
with mlflow.start_run():
mlflow.log_param('model_type', 'xgboost')
mlflow.log_metric('auc', 0.94)
print('Logged to remote server.')Verificação rápida
Teste sua compreensão dos conceitos de Aprendizado de Máquina com Python apresentados nesta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: o MLflow acompanha parâmetros, métricas e artefatos de cada execução de treinamento em um banco de dados pesquisável, mlflow.sklearn.autolog() captura tudo automaticamente, sem chamadas manuais de registro e os modelos registrados na variante sklearn podem ser disponibilizados como APIs REST ou promovidos pelo Registro de Modelos. A seguir, vamos criar contêineres Docker reproduzíveis para o treinamento de modelos de aprendizado de máquina, eliminando as diferenças de ambiente entre as máquinas.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos” é grátis?
Sim — o texto completo de “Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Machine Learning Academy, atualize para CoddyKit PRO. O curso de Machine Learning Academy inclui 4 aulas no total.
O que vou aprender em “Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos”?
Os alunos instrumentarão um script de treinamento com mlflow.log_param e mlflow.log_metric, iniciarão a interface do MLflow e compararão execuções com diferentes configurações de hiperparâmetros. Você pratica Machine Learning Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Machine Learning Academy?
Nenhuma experiência prévia é necessária. Machine Learning Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Machine Learning Academy?
Sim. Cada aula de Machine Learning Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Acompanhamento de experimentos com MLflow: registro de parâmetros, métricas e artefatos
- Ambientes reproduzíveis com Docker para aprendizado de máquina
- Registro de modelos: preparação, produção e arquivamento
- Pipelines automatizados de retreinamento com GitHub Actions