Registrar métricas, parâmetros e arquivos com MLflow

APLICA-SE A: Python SDK azure-ai-ml v2 (atual)

O Azure Machine Learning dá suporte ao registro em log e ao acompanhamento de experimentos usando o MLflow Tracking. Você pode registrar modelos, métricas, parâmetros e artefatos com o MLflow, localmente em seu computador ou em um ambiente de nuvem.

Importante

Ao contrário do SDK do Azure Machine Learning v1, não há funcionalidade de registro em log no SDK do Azure Machine Learning para Python (v2). Se você usou o SDK do Azure Machine Learning v1 antes, recomendamos que aproveite o MLflow para rastrear experimentos. Consulte Migrar o log do SDK v1 para o MLflow para obter orientações específicas.

Os registos podem ajudá-lo a diagnosticar erros e avisos ou a acompanhar métricas de desempenho, como parâmetros e desempenho do modelo. Este artigo explica como habilitar o registro em log nos seguintes cenários:

• Registre métricas, parâmetros e modelos ao enviar trabalhos.
• Acompanhe as corridas ao treinar de forma interativa.
• Registre métricas de forma assíncrona.
• Veja informações de diagnóstico sobre treinamento.

Gorjeta

Este artigo mostra-lhe como monitorizar o processo de preparação do modelo. Se você estiver interessado em monitorar o uso de recursos e eventos do Azure Machine Learning, como cotas, trabalhos de treinamento concluídos ou implantações de modelo concluídas, consulte Monitorando o Azure Machine Learning.

Pré-requisitos

• Você deve ter um espaço de trabalho do Azure Machine Learning. Se você não tiver um, consulte Criar recursos do espaço de trabalho.

• Você deve ter os mlflow pacotes e azureml-mlflow instalados. Caso contrário, use o seguinte comando para instalá-los em seu ambiente de desenvolvimento:

  pip install mlflow azureml-mlflow
  

  Nota

  Para o registro assíncrono de métricas, você precisa ter MLflow a versão 2.8.0+ e azureml-mlflow a versão 1.55+.

• Se você estiver fazendo o rastreamento remoto (rastreando experimentos que são executados fora do Aprendizado de Máquina do Azure), configure o MLflow para rastrear experimentos. Para obter mais informações, consulte Configurar o MLflow para o Azure Machine Learning.

• Para registrar métricas, parâmetros, artefatos e modelos em seus experimentos no Aprendizado de Máquina do Azure usando MLflow, basta importar MLflow para seu script:

  import mlflow
  

Configurar experimentos

O MLflow organiza as informações em experimentos e execuções (no Azure Machine Learning, as execuções são chamadas de trabalhos). Há algumas diferenças em como configurá-los, dependendo de como você executa seu código:

Formação interativa

Ao treinar interativamente, como em um Jupyter Notebook, use o seguinte padrão:

1. Crie ou defina o experimento ativo.
2. Inicie o trabalho.
3. Use métodos de log para registrar métricas e outras informações.
4. Termine o trabalho.

Por exemplo, o trecho de código a seguir configura o experimento e, em seguida, registra em log durante um trabalho:

import mlflow
# Set the experiment
mlflow.set_experiment("mlflow-experiment")

# Start the run
mlflow_run = mlflow.start_run()
# Log metrics or other information
mlflow.log_metric('mymetric', 1)
# End run 
mlflow.end_run()

Gorjeta

Tecnicamente, você não precisa chamar start_run() porque uma nova execução é criada se uma não existir e você chamar uma API de log. Nesse caso, você pode usar mlflow.active_run() para recuperar a execução que está sendo usada no momento. Para obter mais informações, consulte mlflow.ative_run().

Você também pode usar o paradigma do gerenciador de contexto:

import mlflow
mlflow.set_experiment("mlflow-experiment")

# Start the run, log metrics, end the run
with mlflow.start_run() as run:
    # Run started when context manager is entered, and ended when context manager exits
    mlflow.log_metric('mymetric', 1)
    mlflow.log_metric('anothermetric',1)
    pass

Quando você inicia uma nova execução com mlflow.start_runo , pode ser útil indicar o parâmetro run_name, que se traduz para o nome da execução na interface do usuário do Aprendizado de Máquina do Azure e ajuda a identificar a execução mais rapidamente:

with mlflow.start_run(run_name="iris-classifier-random-forest") as run:
    mlflow.log_metric('mymetric', 1)
    mlflow.log_metric('anothermetric',1)

Para obter mais informações sobre APIs de log MLflow, consulte a referência MLflow.

Formação com emprego

Ao executar trabalhos de treinamento no Aprendizado de Máquina do Azure, você não precisa ligar mlflow.start_run porque as execuções são iniciadas automaticamente. Assim, você pode usar os recursos de rastreamento mlflow diretamente em seus scripts de treinamento:

import mlflow

mlflow.autolog()

mlflow.log_metric('mymetric', 1)
mlflow.log_metric('anothermetric',1)

Gorjeta

Ao enviar trabalhos usando a CLI v2 do Azure Machine Learning, você pode definir o nome do experimento usando a propriedade experiment_name na definição YAML do trabalho. Você não precisa configurá-lo em seu script de treinamento. Consulte YAML: nome para exibição, nome do experimento, descrição e tags para obter detalhes.

Parâmetros de log

O MLflow suporta os parâmetros de log usados por seus experimentos. Os parâmetros podem ser de qualquer tipo e podem ser registrados usando a seguinte sintaxe:

mlflow.log_param("num_epochs", 20)

O MLflow também oferece uma maneira conveniente de registrar vários parâmetros, indicando todos eles usando um dicionário. Vários frameworks também podem passar parâmetros para modelos usando dicionários e, portanto, esta é uma maneira conveniente de registrá-los no experimento.

params = {
    "num_epochs": 20,
    "dropout_rate": .6,
    "objective": "binary_crossentropy"
}

mlflow.log_params(params)

Métricas de registo

As métricas, ao contrário dos parâmetros, são sempre numéricas e podem ser registradas de forma síncrona ou assíncrona. Quando as métricas são registradas, elas ficam imediatamente disponíveis para consumo após o retorno da chamada. A tabela a seguir descreve como registrar tipos numéricos específicos:

Valor registado	Código de exemplo	Notas
Registrar um valor numérico (int ou float)	mlflow.log_metric("my_metric", 1)
Registrar um valor numérico (int ou float) ao longo do tempo	mlflow.log_metric("my_metric", 1, step=1)	Use o parâmetro step para indicar a etapa na qual você registra o valor da métrica. Pode ser qualquer número inteiro. O padrão é zero.
Registrar um valor booleano	mlflow.log_metric("my_metric", 0)	0 = Verdadeiro, 1 = Falso

Importante

Considerações de desempenho: se você precisar registrar várias métricas (ou vários valores para a mesma métrica), evite fazer chamadas para mlflow.log_metric loops in. Um melhor desempenho pode ser alcançado usando o registro assíncrono com mlflow.log_metric("metric1", 9.42, synchronous=False) ou registrando um lote de métricas.

Registrar métricas de forma assíncrona

O MLflow também permite o registro de métricas de forma assíncrona. O log de métricas assíncronas é particularmente útil nos casos em que grandes trabalhos de treinamento com dezenas de nós de computação podem estar em execução e tentando registrar métricas simultaneamente. Também é útil quando um pequeno número de nós está tentando registrar um alto número de métricas.

O registro assíncrono de métricas permite registrar métricas imediatamente, evitando esperar que elas se materializem no serviço de back-end. Essa abordagem é dimensionada para grandes rotinas de treinamento que registram centenas de milhares de valores métricos e é a abordagem recomendada.

O MLflow registra métricas de forma síncrona por padrão, no entanto, você pode alterar esse comportamento a qualquer momento:

import mlflow

mlflow.config.enable_async_logging()

A mesma propriedade pode ser definida, usando uma variável de ambiente:

export MLFLOW_ENABLE_ASYNC_LOGGING=True

Para registrar métricas específicas de forma assíncrona, use a API de log MLflow como faria normalmente, mas adicione o parâmetro synchronous=Falseextra .

import mlflow

with mlflow.start_run():
    # (...)
    mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)

Quando você usa log_metric(synchronous=False)o , o controle é automaticamente devolvido ao chamador assim que a operação é aceita, no entanto, o valor não está disponível para leitura imediata. O registro assíncrono de métricas garante a ordem e elas persistem com o carimbo de data/hora de quando foram registradas.

Importante

Mesmo com synchronous=Falseo , o Azure Machine Learning garante a ordenação das métricas.

Se você precisar esperar que um determinado valor seja persistido no back-end, poderá usar a operação de métrica retornada para aguardar nele, conforme mostrado no exemplo a seguir:

import mlflow

with mlflow.start_run():
    # (...)
    run_operation = mlflow.log_metric("metric1", 9.42, synchronous=False)
    # (...)
    run_operation.wait()
    # (...)

Você pode registrar de forma assíncrona uma métrica de cada vez ou registrar um lote de métricas, conforme mostrado no exemplo a seguir:

import mlflow
import time
from mlflow.entities import Metric

with mlflow.start_run() as current_run:
    mlflow_client = mlflow.tracking.MlflowClient()

    metrics = {"metric-0": 3.14, "metric-1": 6.28}
    timestamp = int(time.time() * 1000)
    metrics_arr = [Metric(key, value, timestamp, 0) for key, value in metrics.items()]

    run_operation = mlflow_client.log_batch(
        run_id=current_run.info.run_id,
        metrics=metrics_arr,
        synchronous=False,
    )

A wait() operação também está disponível ao registrar um lote de métricas:

run_operation.wait()

Você não precisa recorrer wait() às suas rotinas se não precisar de acesso imediato aos valores métricos. O Aprendizado de Máquina do Azure aguarda automaticamente quando o trabalho está prestes a ser concluído, para ver se há alguma métrica pendente a ser persistida. No momento em que um trabalho é concluído no Azure Machine Learning, todas as métricas têm a garantia de persistir.

Curvas de log ou lista de valores

As curvas (ou uma lista de valores numéricos) podem ser registradas com MLflow registrando a mesma métrica várias vezes. O exemplo a seguir mostra como fazê-lo:

list_to_log = [1, 2, 3, 2, 1, 2, 3, 2, 1]
from mlflow.entities import Metric
from mlflow.tracking import MlflowClient
import time

client = MlflowClient()
client.log_batch(mlflow.active_run().info.run_id, 
                 metrics=[Metric(key="sample_list", value=val, timestamp=int(time.time() * 1000), step=0) for val in list_to_log])

Registrar imagens

O MLflow suporta duas maneiras de registrar imagens. Ambas as maneiras persistem a imagem dada como um artefato dentro da corrida.

Valor registado	Código de exemplo	Notas
Registrar métricas numpy ou objetos de imagem PIL	mlflow.log_image(img, "figure.png")	img deve ser um exemplo de numpy.ndarray ou PIL.Image.Image. figure.png é o nome do artefato gerado dentro da corrida. Não precisa ser um arquivo existente.
Registrar gráfico matplotlib ou arquivo de imagem	mlflow.log_figure(fig, "figure.png")	figure.png é o nome do artefato gerado dentro da corrida. Não precisa ser um arquivo existente.

Ficheiros de registo

Em geral, os arquivos no MLflow são chamados de artefatos. Você pode registrar artefatos de várias maneiras no Mlflow:

Valor registado	Código de exemplo	Notas
Registrar texto em um arquivo de texto	mlflow.log_text("text string", "notes.txt")	O texto é persistido dentro da execução em um arquivo de texto com nome notes.txt.
Dicionários de log como arquivos JSON e YAML	mlflow.log_dict(dictionary, "file.yaml"	dictionary é um objeto de dicionário que contém toda a estrutura que você deseja persistir como um arquivo JSON ou YAML.
Registrar um arquivo trivial já existente	mlflow.log_artifact("path/to/file.pkl")	Os arquivos são sempre registrados na raiz da execução. Se artifact_path for fornecido, o arquivo é registrado em uma pasta, conforme indicado nesse parâmetro.
Registrar todos os artefatos em uma pasta existente	mlflow.log_artifacts("path/to/folder")	A estrutura de pastas é copiada para a execução, mas a pasta raiz indicada não está incluída.

Gorjeta

Quando você registra arquivos grandes com log_artifact ou log_model, você pode encontrar erros de tempo limite antes que o upload do arquivo seja concluído. Considere aumentar o valor de tempo limite ajustando a variável AZUREML_ARTIFACTS_DEFAULT_TIMEOUTde ambiente . Seu valor padrão é 300 (segundos).

Modelos de log

O MLflow introduz o conceito de modelos como uma forma de empacotar todos os artefatos necessários para que um determinado modelo funcione. Os modelos no MLflow são sempre uma pasta com um número arbitrário de arquivos, dependendo da estrutura usada para gerar o modelo. Os modelos de registro em log têm a vantagem de rastrear todos os elementos do modelo como uma única entidade que pode ser registrada e, em seguida, implantada. Além disso, os modelos MLflow desfrutam do benefício da implantação sem código e podem ser usados com o painel de IA responsável em estúdio. Para obter mais informações, consulte De artefatos a modelos no MLflow.

Para salvar o modelo de uma execução de treinamento, use a log_model() API para a estrutura com a qual você está trabalhando. Por exemplo, mlflow.sklearn.log_model(). Para obter mais informações, consulte Registrando modelos MLflow. Para migrar modelos existentes para MLflow, consulte Converter modelos personalizados em MLflow.

Gorjeta

Quando você registra modelos grandes, você pode encontrar o erro Failed to flush the queue within 300 seconds. Normalmente, isso significa que a operação está expirando antes que o upload dos artefatos do modelo seja concluído. Considere aumentar o valor de tempo limite ajustando a variável AZUREML_ARTIFACTS_DEFAULT_TIMEOUTde ambiente .

Registo automático

Com o Azure Machine Learning e o MLflow, os usuários podem registrar métricas, parâmetros de modelo e artefatos de modelo automaticamente ao treinar um modelo. Cada estrutura decide o que rastrear automaticamente para você. Uma variedade de bibliotecas populares de aprendizado de máquina são suportadas. Saiba mais sobre o registo automático com MLflow.

Para habilitar o registro automático, insira o seguinte código antes do código de treinamento:

mlflow.autolog()

Gorjeta

Você pode controlar o que é registrado automaticamente com o autolog. Por exemplo, se você indicar mlflow.autolog(log_models=False), o MLflow registra tudo, exceto modelos, para você. Esse controle é útil nos casos em que você deseja registrar modelos manualmente, mas ainda desfruta do registro automático de métricas e parâmetros. Além disso, observe que algumas estruturas podem desabilitar o registro automático de modelos se o modelo treinado ultrapassar limites específicos. Tal comportamento depende do sabor usado e recomendamos que você veja a documentação se este for o seu caso.

Exibir informações sobre trabalhos ou execuções com MLflow

Você pode exibir as informações registradas usando MLflow através do objeto MLflow.entities.Run :

import mlflow

run = mlflow.get_run(run_id="<RUN_ID>")

Você pode exibir as métricas, parâmetros e tags para a execução no campo de dados do objeto de execução.

metrics = run.data.metrics
params = run.data.params
tags = run.data.tags

Nota

O dicionário de métricas retornado por mlflow.get_run ou mlflow.search_runs retorna apenas o valor registrado mais recentemente para um determinado nome de métrica. Por exemplo, se você registrar uma métrica chamada iteration várias vezes com valores, 1, 2, 3 e 4, apenas 4 será retornado ao chamar .run.data.metrics['iteration']

Para obter todas as métricas registradas para um nome de métrica específico, você pode usar MlFlowClient.get_metric_history() como explicado no exemplo Obtendo parâmetros e métricas de uma execução.

Gorjeta

O MLflow pode recuperar métricas e parâmetros de várias execuções ao mesmo tempo, permitindo comparações rápidas entre várias tentativas. Para saber mais, consulte Consultar & comparar experimentos e execuções com MLflow.

O MLflow pode consultar qualquer artefato registrado por uma execução. Os artefatos não podem ser acessados usando o próprio objeto run e o cliente MLflow deve ser usado:

client = mlflow.tracking.MlflowClient()
client.list_artifacts("<RUN_ID>")

Esse método lista todos os artefatos registrados na execução, mas eles permanecem armazenados no repositório de artefatos (armazenamento do Azure Machine Learning). Para baixar qualquer um deles, use o método download_artifact:

file_path = client.download_artifacts("<RUN_ID>", path="feature_importance_weight.png")

Para obter mais informações, consulte Obter métricas, parâmetros, artefatos e modelos.

Ver informações sobre trabalhos ou execuções no estúdio

Você pode procurar registros de trabalho concluídos, incluindo métricas registradas, no estúdio do Azure Machine Learning.

Navegue até a guia Trabalhos . Para exibir todos os seus trabalhos em seu espaço de trabalho em Experimentos, selecione a guia Todos os trabalhos . Você pode detalhar trabalhos para experimentos específicos aplicando o filtro Experimento na barra de menu superior. Selecione o trabalho de interesse para inserir a visualização de detalhes e, em seguida, selecione a guia Métricas .

Selecione as métricas registradas para renderizar gráficos no lado direito. Você pode personalizar os gráficos aplicando suavização, alterando a cor ou plotando várias métricas em um único gráfico. Você também pode redimensionar e reorganizar o layout como desejar. Depois de criar a visualização desejada, você pode salvá-la para uso futuro e compartilhá-la com seus colegas de equipe usando um link direto.

Visualizar e baixar logs de diagnóstico

Os arquivos de log são um recurso essencial para depurar as cargas de trabalho do Azure Machine Learning. Depois de enviar um trabalho de treinamento, faça uma busca detalhada em uma execução específica para visualizar seus logs e saídas:

1. Navegue até a guia Trabalhos .
2. Selecione o runID para uma execução específica.
3. Selecione Saídas e logs na parte superior da página.
4. Selecione Baixar tudo para baixar todos os seus logs em uma pasta zip.
5. Você também pode baixar arquivos de log individuais escolhendo o arquivo de log e selecionando Download

user_logs pasta

Esta pasta contém informações sobre os logs gerados pelo usuário. Essa pasta é aberta por padrão e o log de std_log.txt é selecionado. O std_log.txt é onde os logs do seu código (por exemplo, instruções de impressão) aparecem. Este arquivo contém stdout log e stderr logs do seu script de controle e script de treinamento, um por processo. Na maioria dos casos, você monitora os logs aqui.

system_logs pasta

Esta pasta contém os logs gerados pelo Azure Machine Learning e é fechada por padrão. Os logs gerados pelo sistema são agrupados em diferentes pastas, com base no estágio do trabalho no tempo de execução.

Outras pastas

Para treinamento de trabalhos em clusters de multicomputação, os logs estão presentes para cada nó IP. A estrutura para cada nó é a mesma que os trabalhos de nó único. Há mais uma pasta de logs para execução geral, stderr e stdout logs.

O Aprendizado de Máquina do Azure registra informações de várias fontes durante o treinamento, como o AutoML ou o contêiner do Docker que executa o trabalho de treinamento. Muitos desses logs não estão documentados. Se você encontrar problemas e entrar em contato com o suporte da Microsoft, eles poderão usar esses logs durante a solução de problemas.

Conteúdos relacionados

• Treinar modelos de ML com MLflow e Azure Machine Learning
• Migrar do log do SDK v1 para o rastreamento de MLflow