Exibir resultados de treinamento com execuções de operações do MLflow

Este artigo descreve como usar as execuções do MLflow para exibir e analisar os resultados de um experimento de treinamento de modelo e como gerenciar e organizar execuções. Para obter mais informações sobre experimentos do MLflow, consulte Organizar execuções de treinamento com experimentos do MLflow.

Uma execução do MLflow corresponde a uma única execução do código do modelo. Cada execução registra informações como o notebook que iniciou a execução, todos os modelos criados pela execução, parâmetros de modelo e métricas salvos como pares chave-valor, marcas para metadados de execução e quaisquer artefatos ou arquivos de saída, criados pela execução.

Todas as execuções do MLflow são registradas no experimento ativo. Se você não definiu explicitamente um experimento como o experimento ativo, as execuções serão registradas no experimento do notebook.

Exibir detalhes da execução

Você pode acessar uma execução na página de detalhes do experimento ou diretamente do bloco de anotações que criou a execução.

Na página de detalhes do experimento, clique no nome da execução na tabela de execuções.

No notebook, clique no nome da execução na barra lateral Execuções de Experimento.

A tela de execução mostra a ID de execução, os parâmetros usados para a execução, as métricas resultantes da execução e os detalhes sobre a execução, incluindo um link para o notebook de origem. Os artefatos salvos da execução estão disponíveis na guia Artefatos.

Trechos de código para previsão

Se você registrar um modelo a partir de uma execução, o modelo aparecerá na guia Artefatos, juntamente com snippets de código que ilustram como carregar e usar o modelo para fazer previsões em DataFrames do Spark e Pandas. No MLflow 3, os modelos agora são seu objeto de primeira classe distinto em vez de serem registrados como artefato de execução. Para obter mais informações, consulte Introdução ao MLflow 3 para modelos.

Exibir o notebook usado para uma execução

Para exibir a versão do notebook que criou uma execução:

• Na página de detalhes do experimento, clique no link na coluna Origem .
• Na página executar, clique no link ao lado de Origem.
• No notebook, na barra lateral de execuções de Experimentos, clique no ícone Notebook na caixa da Execução do Experimento.

A versão do notebook associado à execução é exibida na janela principal com uma barra de realce mostrando a data e a hora da execução.

Adicionar uma marca a uma execução

As marcas são pares chave-valor que você pode criar e usar depois para pesquisar execuções.

1. Na tabela Detalhes na página de execução, clique em Adicionar marcas ao lado de Marcas.

   

2. A caixa de diálogo Adicionar/Editar marcas é aberta. No campo Chave , insira um nome para a chave e clique em Adicionar marca.

   

3. No campo Valor, insira o valor da etiqueta.

4. Clique no sinal de mais para salvar o par chave-valor que você acabou de inserir.

   

5. Para adicionar marcas adicionais, repita as etapas de 2 a 4.

6. Quando terminar, clique em Salvar marcas.

Editar ou excluir uma marca para uma execução

1. Na tabela Detalhes na página de execução, clique no ao lado das marcas existentes.

   

2. A caixa de diálogo Adicionar/Editar marcas é aberta.

   1. Para excluir uma etiqueta, clique no X dessa etiqueta.

      

   2. Para editar uma tag, selecione a chave no menu suspenso e edite o valor no campo Value. Clique no ícone de mais para salvar a alteração.

      

3. Quando terminar, clique em Salvar marcas.

Reproduzir o ambiente de software de uma execução

Você pode reproduzir o ambiente de software exato para a execução clicando em Reproduzir Executar no canto superior direito da página de execução. A caixa de diálogo a seguir é exibida:

Com as configurações padrão, quando você clica em Confirmar:

• O notebook é clonado para o local mostrado na caixa de diálogo.
• Se o cluster original ainda existir, o notebook clonado será anexado ao cluster original, e o cluster será iniciado.
• Se o cluster original não existir mais, um novo cluster com a mesma configuração, incluindo todas as bibliotecas instaladas, será criado e iniciado. O notebook está anexado ao novo cluster.

Você pode selecionar um local diferente para o notebook clonado e inspecionar a configuração do cluster e as bibliotecas instaladas:

• Para selecionar uma pasta diferente para salvar o notebook clonado, clique em Editar pasta.
• Para ver a especificação do cluster, clique em Exibir especificação. Para clonar apenas o notebook e não o cluster, desmarque essa opção.
• Se o cluster original não existir mais, você poderá ver as bibliotecas instaladas no cluster original clicando em Exibir Bibliotecas. Se o cluster original ainda existir, esta seção ficará esmaecida.

Renomear execução

Para renomear uma execução, clique no No canto superior direito da página de execução (ao lado do botão Permissões) e selecione Renomear.

Selecionar colunas a serem exibidas

Para controlar as colunas exibidas na tabela de execuções na página de detalhes do experimento, clique em Colunas e selecione uma opção no menu suspenso.

Filtrar execuções

Você pode pesquisar execuções na tabela na página de detalhes do experimento com base em valores de parâmetros ou métricas. Você também pode procurar execuções por marca.

• Para pesquisar execuções que correspondam a uma expressão que contém valores de parâmetro e métrica, insira uma consulta no campo de pesquisa e pressione Enter. Alguns exemplos de sintaxe de consulta são:

  metrics.r2 > 0.3

  params.elasticNetParam = 0.5

  params.elasticNetParam = 0.5 AND metrics.avg_areaUnderROC > 0.3

  MIN(metrics.rmse) <= 1

  MAX(metrics.memUsage) > 0.9

  LATEST(metrics.memUsage) = 0 AND MIN(metrics.rmse) <= 1

  Por padrão, os valores de métrica são filtrados com base no último valor registrado em log. Usar MIN ou MAX permite localizar execuções com base nos valores de métrica mínimo ou máximo, respectivamente. Somente execuções registradas em log após agosto de 2024 têm valores de métrica mínimos e máximos.

• Para pesquisar as execuções por marca, insira marcas no formato: tags.<key>="<value>". Os valores de cadeia de caracteres devem estar entre aspas, conforme mostrado.

  tags.estimator_name="RandomForestRegressor"

  tags.color="blue" AND tags.size=5

  As chaves e os valores podem conter espaços. Se a chave incluir espaços, você deverá incluí-la nos ativos, conforme mostrado.

  tags.`my custom tag` = "my value"
  

Você também pode filtrar execuções com base em seu estado (Ativo ou Excluído), quando a execução foi criada e quais conjuntos de dados foram usados. Para fazer isso, faça suas seleções nos menus suspensos Time created, State ou Datasets , respectivamente.

Download de execuções

Você pode baixar resultados na página de detalhes do experimento da seguinte maneira:

1. Clique no Para abrir o menu de kebab.

   

2. Para baixar um arquivo no formato CSV contendo todas as execuções mostradas (até um máximo de 100), selecione Baixar execuções<n>. O MLflow cria e baixa um arquivo com uma execução por linha, contendo os seguintes campos para cada execução:

   Start Time, Duration, Run ID, Name, Source Type, Source Name, User, Status, <parameter1>, <parameter2>, ..., <metric1>, <metric2>, ...
   

3. Se você quiser baixar mais de 100 execuções ou quiser baixar execuções programaticamente, selecione Baixar todas as execuções. Uma caixa de diálogo é aberta mostrando um snippet de código que você pode copiar ou abrir em um bloco de anotações. Depois de executar esse código em uma célula de notebook, selecione Baixar todas as linhas da saída da célula.

Excluir as execuções

Você pode excluir execuções da página de detalhes do experimento seguindo estas etapas:

1. No experimento, selecione uma ou mais execuções clicando na caixa de seleção à esquerda da execução.
2. Clique em Excluir.
3. Se a execução for pai, decida se você também deseja excluir as execuções descendentes. Por padrão, essa opção é selecionada.
4. Clique em Excluir para confirmar. As execuções excluídas são salvas por 30 dias. Para exibir as execuções excluídas, selecione Excluído no campo Estado.

Exclusão em massa de execuções baseada no tempo de criação

Você pode usar o Python para excluir em massa as execuções de um experimento que foram criados antes ou em um carimbo de data/hora UNIX. Ao usar o Databricks Runtime 14.1 ou posterior, você pode chamar a API mlflow.delete_runs para excluir execuções e retornar o número de execuções excluídas.

Veja a seguir os parâmetros de mlflow.delete_runs:

• experiment_id: a ID do experimento contendo as execuções a serem excluídas.
• max_timestamp_millis: o carimbo de data/hora máximo de criação em milissegundos desde a época do UNIX para excluir as execuções. Somente as execuções criadas antes ou nesse carimbo de data/hora são excluídas.
• max_runs: opcional. Um inteiro positivo que indica o número máximo de execuções a serem excluídas. O valor máximo permitido para max_runs é 10000. Se não for especificado, o padrão max_runs será 10000.

import mlflow

# Replace <experiment_id>, <max_timestamp_ms>, and <max_runs> with your values.
runs_deleted = mlflow.delete_runs(
  experiment_id=<experiment_id>,
  max_timestamp_millis=<max_timestamp_ms>,
  max_runs=<max_runs>
)
# Example:
runs_deleted = mlflow.delete_runs(
  experiment_id="4183847697906956",
  max_timestamp_millis=1711990504000,
  max_runs=10
)

Ao usar o Databricks Runtime 13.3 LTS ou anterior, você pode executar o código de cliente a seguir em um Notebook do Azure Databricks.

from typing import Optional

def delete_runs(experiment_id: str,
                max_timestamp_millis: int,
                max_runs: Optional[int] = None) -> int:
    """
    Bulk delete runs in an experiment that were created prior to or at the specified timestamp.
    Deletes at most max_runs per request.

    :param experiment_id: The ID of the experiment containing the runs to delete.
    :param max_timestamp_millis: The maximum creation timestamp in milliseconds
                                 since the UNIX epoch for deleting runs. Only runs
                                 created prior to or at this timestamp are deleted.
    :param max_runs: Optional. A positive integer indicating the maximum number
                     of runs to delete. The maximum allowed value for max_runs
                     is 10000. If not specified, max_runs defaults to 10000.
    :return: The number of runs deleted.
    """
    from mlflow.utils.databricks_utils import get_databricks_host_creds
    from mlflow.utils.request_utils import augmented_raise_for_status
    from mlflow.utils.rest_utils import http_request

    json_body = {"experiment_id": experiment_id, "max_timestamp_millis": max_timestamp_millis}
    if max_runs is not None:
        json_body["max_runs"] = max_runs
    response = http_request(
        host_creds=get_databricks_host_creds(),
        endpoint="/api/2.0/mlflow/databricks/runs/delete-runs",
        method="POST",
        json=json_body,
    )
    augmented_raise_for_status(response)
    return response.json()["runs_deleted"]

Consulte a documentação da API de Experimentos do Azure Databricks para obter os parâmetros e as especificações do valor retornado para excluir execuções com base na hora da criação.

Restaurar execuções

Você pode restaurar execuções excluídas anteriormente da interface do usuário da seguinte maneira:

1. Na página Experimento , no campo Estado , selecione Excluído para exibir execuções excluídas.
2. Selecione uma ou mais execuções clicando na caixa de seleção à esquerda da execução.
3. Clique em Restaurar.
4. Clique em Restaurar para confirmar. As execuções restauradas agora aparecem quando você seleciona Ativo no campo Estado.

Execuções de restauração em massa com base no tempo de exclusão

Você também pode usar o Python para restaurar em massa as execuções de um experimento que foram excluídas em ou após um carimbo de data/hora UNIX. Ao usar o Databricks Runtime 14.1 ou posterior, você pode chamar a API mlflow.restore_runs para restaurar as execuções e retornar o número de execuções restauradas.

Veja a seguir os parâmetros de mlflow.restore_runs:

• experiment_id: a ID do experimento contendo as execuções a serem restauradas.
• min_timestamp_millis: o carimbo de data/hora máximo de exclusão em milissegundos desde a época do UNIX para restaurar as execuções. Somente as execuções excluídas nesse carimbo de data/hora ou depois dele são restauradas.
• max_runs: opcional. Um inteiro positivo que indica o número máximo de execuções a serem restauradas. O valor máximo permitido para max_runs é 10000. Se não for especificado, max_runs padrão será 10000.

import mlflow

# Replace <experiment_id>, <min_timestamp_ms>, and <max_runs> with your values.
runs_restored = mlflow.restore_runs(
  experiment_id=<experiment_id>,
  min_timestamp_millis=<min_timestamp_ms>,
  max_runs=<max_runs>
)
# Example:
runs_restored = mlflow.restore_runs(
  experiment_id="4183847697906956",
  min_timestamp_millis=1711990504000,
  max_runs=10
)

Ao usar o Databricks Runtime 13.3 LTS ou anterior, você pode executar o código de cliente a seguir em um Notebook do Azure Databricks.

from typing import Optional

def restore_runs(experiment_id: str,
                 min_timestamp_millis: int,
                 max_runs: Optional[int] = None) -> int:
    """
    Bulk restore runs in an experiment that were deleted at or after the specified timestamp.
    Restores at most max_runs per request.

    :param experiment_id: The ID of the experiment containing the runs to restore.
    :param min_timestamp_millis: The minimum deletion timestamp in milliseconds
                                 since the UNIX epoch for restoring runs. Only runs
                                 deleted at or after this timestamp are restored.
    :param max_runs: Optional. A positive integer indicating the maximum number
                     of runs to restore. The maximum allowed value for max_runs
                     is 10000. If not specified, max_runs defaults to 10000.
    :return: The number of runs restored.
    """
    from mlflow.utils.databricks_utils import get_databricks_host_creds
    from mlflow.utils.request_utils import augmented_raise_for_status
    from mlflow.utils.rest_utils import http_request
    json_body = {"experiment_id": experiment_id, "min_timestamp_millis": min_timestamp_millis}
    if max_runs is not None:
        json_body["max_runs"] = max_runs
    response = http_request(
        host_creds=get_databricks_host_creds(),
        endpoint="/api/2.0/mlflow/databricks/runs/restore-runs",
        method="POST",
        json=json_body,
    )
    augmented_raise_for_status(response)
    return response.json()["runs_restored"]

Consulte a documentação da API de Experimentos do Azure Databricks para obter os parâmetros e as especificações do valor retornado para a restauração de execuções com base na hora da exclusão.

Comparar execuções

Você pode comparar execuções de um único experimento ou de vários experimentos. A página Comparando Execuções apresenta informações sobre as execuções selecionadas no formato tabular. Você também pode criar visualizações de resultados de execução e tabelas de informações de execução, parâmetros de execução e métricas. Consulte Comparar execuções e modelos do MLflow usando gráficos.

As tabelas Parâmetros e Métricas exibem os parâmetros de execução e as métricas de todas as execuções selecionadas. As colunas nessas tabelas são identificadas pela tabela Detalhes da Execução imediatamente acima. Para simplificar, você pode ocultar parâmetros e métricas que são idênticos em todas as execuções selecionadas, alternando .

Comparar execuções de um único experimento

1. Na página de detalhes do experimento, selecione duas ou mais execuções clicando na caixa de seleção à esquerda da execução ou selecione todas as execuções marcando a caixa na parte superior da coluna.
2. Clique em Comparar. A tela Comparação <N> é exibida.

Comparar execuções de vários experimentos

1. Na página de experimentos, selecione os experimentos que você deseja comparar clicando na caixa à esquerda do nome do experimento.
2. Clique em Comparar (n) (n é o número de experimentos selecionados). Uma tela é exibida mostrando todas as execuções dos experimentos selecionados.
3. Selecione duas ou mais execuções clicando na caixa de seleção à esquerda da execução ou selecione todas as execuções marcando a caixa na parte superior da coluna.
4. Clique em Comparar. A tela Comparação <N> é exibida.

Comparar execuções usando tabelas do sistema

Os metadados do MLflow para experimentos e execuções também estão disponíveis nas tabelas do sistema, em que você pode aproveitar o DATAbricks SQL e todas as ferramentas do Lakehouse que o Databricks oferece para analisar os dados do experimento. Para obter mais detalhes, consulte a referência de tabelas do sistema MLflow.

Copiar execuções entre workspaces

Para importar ou exportar execuções do MLflow para o workspace do Databricks, é possível usar o projeto de software livre orientado pela comunidade MLflow Export-Import.