Acompanhamento e observabilidade de experimentos

Importante

Esse recurso está em Visualização Pública.

O rastreamento e a observabilidade de experimento estão integrados ao Runtime da IA. MLflow é um único local para os parâmetros de uma execução, métricas, métricas do sistema GPU, logs e artefatos. Cada execução fica em um experimento MLflow que você pode compartilhar com sua equipe, e um painel de recursos da GPU embutido mostra a utilização ao vivo da GPU, memória e temperatura enquanto seu código roda.

Pontos-chave desta página:

• MLflow é a interface unificada para experimentos de IA em tempo de execução: métricas, parâmetros, métricas do sistema, logs e artefatos.
• As cargas de trabalho enviadas com a CLI do Databricks recebem automaticamente uma execução do MLflow. Em cadernos e scripts, chame mlflow.start_run() ou mlflow.autolog().
• Um painel de recursos da GPU embutido mostra utilização, memória e temperatura.

O que o MLflow oferece para aprendizado profundo

• Métricas e parâmetros: Registre a perda de treinamento, métricas de avaliação, taxa de aprendizado e hiperparâmetros, e compare entre execuções na interface do MLflow.
• Métricas do sistema: GPU, CPU e utilização de memória registradas junto com suas métricas de treinamento na aba de métricas do sistema da execução.
• Logs: saída do driver da execução do trabalho na guia Logs da execução.
• Artefatos e modelos: armazene arquivos de modelo, configurações e outras saídas junto com a execução. Artefatos podem ser armazenados em um volume do Unity Catalog.
• Compartilhamento e colaboração: experimentos são objetos de workspace. Dê aos membros da equipe acesso a um experimento para compartilharem execuções e compararem resultados. Consulte Executar treinos com experimentos do MLflow.
• Integrações de estruturas: Hugging Face Transformers, PyTorch Lightning e outras bibliotecas fazem login diretamente no MLflow.

Para padrões de aprendizado profundo no MLflow 3, veja o fluxo de trabalho de aprendizado profundo do MLflow 3.

Preciso adicionar os código do MLflow?

Depende de como você envia a carga de trabalho:

Como você executa	A execução do MLflow foi criada automaticamente?	O que você adiciona
Databricks CLI (databricks air run)	Sim. experiment_name no YAML da carga de trabalho define-se o experimento e as métricas e os logs do sistema são coletados sem código.	Optional. Registre em log as métricas personalizadas na execução em MLFLOW_RUN_ID. Consulte Rastrear execuções com MLflow e a página de execução de trabalhos.
API da GPU sem servidor (@distributed)	Sim. Cada chamada de .distributed() cria uma execução.	Optional. Registre as métricas personalizadas dentro da função.
Notebook ou script em um único nó	No. O registro em log automático não está habilitado automaticamente na computação sem servidor.	Chame mlflow.start_run() e registre as métricas ou chame mlflow.autolog().

Introdução

Use o MLflow 3.7 ou posterior. Os exemplos a seguir estão prontos para copiar para uma célula de notebook ou um script Python.

Registrar em log as métricas de um loop de treinamento

import mlflow

mlflow.set_experiment("/Users/<username>/my-experiment")

with mlflow.start_run(run_name="baseline-lr3e-4"):
    mlflow.log_params({"learning_rate": 3e-4, "batch_size": 32, "epochs": 3})
    for epoch in range(3):
        train_loss = train_one_epoch(model, train_loader, optimizer)  # your training code
        val_loss = evaluate(model, val_loader)
        mlflow.log_metrics({"train_loss": train_loss, "val_loss": val_loss}, step=epoch)

Usar o registro em log automático

No PyTorch Lightning, chame mlflow.pytorch.autolog() antes do treinamento. Para outras bibliotecas com suporte, chame mlflow.autolog().

import mlflow

mlflow.pytorch.autolog()

with mlflow.start_run(run_name="lightning-baseline"):
    trainer.fit(model, datamodule=datamodule)

Log do Hugging Face Transformers

Defina report_to="mlflow". O argumento run_name define o nome da execução do MLflow.

from transformers import TrainingArguments

args = TrainingArguments(
    output_dir="/Volumes/<catalog>/<schema>/<volume>/checkpoints",
    report_to="mlflow",
    run_name="llama7b-sft-lr3e5",
    logging_steps=50,
)

Log de múltiplas GPUs

No treinamento distribuído, todo o processo executa o código de treinamento. Registre em log direto do rank 0 de forma que cada métrica seja registrada uma vez:

import os

import mlflow

if int(os.environ.get("RANK", "0")) == 0:
    mlflow.log_metric("train_loss", loss, step=step)

Práticas recomendadas

• Defina step como um valor significativo, como o lote global ou a época, e faça o registro em intervalos (por exemplo, a cada 50 passos), em vez de registrar a cada lote. O MLflow limita o número de etapas de métrica por execução. Confira Limites de recursos.
• Use caminhos de experimento absolutos, como /Users/<username>/my-experiment ou /Workspace/Shared/<team>/my-experiment. Coloque os experimentos que deseja compartilhar em uma pasta compartilhada.
• Para retomar uma execução anterior, forneça a ID dela: mlflow.start_run(run_id="<previous-run-id>").

Serverless GPU API

Quando você usa a API da GPU Sem Servidor, cada chamada de .distributed() cria automaticamente uma execução do MLflow. O experimento padrão é /Users/{WORKSPACE_USER}/{notebook-name}.

• Se você chamar .distributed() dentro de uma execução ativa do MLflow, ela criará uma execução filha aninhada nessa execução:

  import mlflow
  
  with mlflow.start_run() as outer_run:
      run_train.distributed()  # creates a nested child run under outer_run
  

• Para usar um experimento diferente, chame mlflow.set_experiment() antes de .distributed() ou defina a variável de ambiente MLFLOW_EXPERIMENT_NAME. Sempre use caminhos absolutos.

  import os
  
  import mlflow
  
  mlflow.set_experiment("/Users/<username>/my-experiment")
  # or: os.environ["MLFLOW_EXPERIMENT_NAME"] = "/Users/<username>/my-experiment"
  run_train.distributed()
  

• Para retomar uma execução anterior, defina MLFLOW_RUN_ID antes de chamar .distributed():

  os.environ["MLFLOW_RUN_ID"] = "<previous-run-id>"
  run_train.distributed()
  

Exibindo logs

• Saída do Notebook: a saída padrão e os erros do seu código de treinamento aparecem na saída da célula do notebook.
• Logs do MLflow: a interface do usuário do experimento MLflow exibe métricas de treinamento, parâmetros e artefatos.

Se você não puder visualizar os registros

A aba Logs na página de execução do MLflow transmite os logs da execução de trabalhos Databricks associada à execução do MLflow, então o acesso é regido pelas permissões desse trabalho. Se a aba mostrar que você não tem acesso a esses logs, então não tem permissões suficientes.

O acesso à execução no MLflow não implica acesso ao job. Você pode ter a permissão para o experimento do MLflow e ainda assim ter o acesso aos logs negado. Para acessar, peça a um usuário com permissões Pode Gerenciar ou a um administrador de workspace para conceder pelo menos a permissão Pode Exibir no trabalho. Veja Controle de acesso a uma tarefa para saber como as permissões de tarefa são concedidas.

Monitorar recursos da GPU

O painel de recursos da GPU é um recurso de conveniência para sessões de notebook. Ele mostra saúde e utilização da GPU ao vivo sem nenhuma configuração de MLflow, então é especialmente útil quando sua sessão de notebook não cria um experimento MLflow. Para um registro persistente de métricas de GPU, CPU e memória vinculadas a uma execução, use a aba de métricas do Sistema MLflow. O painel oferece suporte a cargas de trabalho de nó único e de vários nós.

Para abrir o painel, conecte seu notebook ao AI Runtime e, no painel lateral direito, clique em Recursos de GPU

O painel exibe as seguintes métricas para cada GPU:

• Percentual de utilização da GPU
• Uso de memória de GPU
• Temperatura

O painel consulta as métricas a cada 10 segundos e mantém até 2 horas de histórico. Clique Atualize para buscar os valores mais recentes imediatamente. Após 5 minutos de inatividade, o painel pausa; reabra-o para retomar o monitoramento.

Limites globais em Azure Databricks

Confira Limites de recursos.