Compartilhar via

Registrar e exibir métricas e arquivos de log v1

  • Artigo

APLICA-SE ASDK do Python azureml v1

Registrar informações em tempo real usando o pacote de log padrão do Python e a funcionalidade específica do SDK do Azure Machine Learning para Python. Você pode fazer logon localmente e enviar os logs para o seu workspace no portal.

Os logs podem ajudar você a diagnosticar erros e avisos ou acompanhar métricas de desempenho como parâmetros e desempenho do modelo. Neste artigo, você aprenderá a habilitar o log nos seguintes cenários:

  • Métricas de execução de log
  • Sessões de treinamento interativo
  • Envio de trabalhos de treinamento por meio do ScriptRunConfig
  • Configurações do logging nativo do Python
  • Log em fontes adicionais

Dica

Este artigo mostra como monitorar o processo de treinamento do modelo. Se você estiver interessado em monitorar o uso de recursos e eventos do Azure Machine Learning, como cotas, execuções de treinamento concluídas ou implantações de modelo concluídas, confira Monitoramento do Azure Machine Learning.

Tipos de dados

Registre em log vários tipos de dados, incluindo valores escalares, listas, tabelas, imagens, diretórios, entre outros. Para obter mais informações e exemplos de código Python para diferentes tipos de dados, confira a página de referência da Classe de execução.

Métricas de execução de registro em log

Use os métodos a seguir nas APIs de registro em log para influenciar as visualizações de métricas. Observe os limites de serviço para essas métricas registradas.

Valor conectado Código de exemplo Formato no portal
Registrar uma matriz de valores numéricos run.log_list(name='Fibonacci', value=[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]) gráfico de linhas de variável único
Registre um único valor numérico com o mesmo nome de métrica usado repetidamente (como em um loop for) for i in tqdm(range(-10, 10)): run.log(name='Sigmoid', value=1 / (1 + np.exp(-i))) angle = i / 2.0 Gráfico de linhas de variável-único
Faça uma linha com colunas numéricas 2 repetidamente run.log_row(name='Cosine Wave', angle=angle, cos=np.cos(angle)) sines['angle'].append(angle) sines['sine'].append(np.sin(angle)) Gráfico de linhas de duas variáveis
Tabela de log com 2 colunas numéricas run.log_table(name='Sine Wave', value=sines) Gráfico de linhas de duas variáveis
Imagem de log run.log_image(name='food', path='./breadpudding.jpg', plot=None, description='desert') Use esse método para registrar um arquivo de imagem ou um gráfico matplotlib à execução. Essas imagens serão visíveis e comparáveis no registro de execução.

Como registrar em log com o MLflow

É recomendável registrar seus modelos, métricas e artefatos com MLflow por ser um código-fonte aberto e oferecer suporte ao modo local para portabilidade de nuvem. A tabela e os exemplos de código a seguir mostram como usar o MLflow para registrar métricas e artefatos de suas execuções de treinamento. Saiba mais sobre os métodos de registro em log do MLflow e padrões de design.

Certifique-se de instalar os pacotes de PIP mlflow e azureml-mlflow no seu workspace.

pip install mlflow
pip install azureml-mlflow

Defina o URI de acompanhamento do MLflow para apontar para o back-end do Azure Machine Learning para garantir que suas métricas e artefatos sejam registrados em seu espaço de trabalho.

from azureml.core import Workspace
import mlflow
from mlflow.tracking import MlflowClient

ws = Workspace.from_config()
mlflow.set_tracking_uri(ws.get_mlflow_tracking_uri())

mlflow.create_experiment("mlflow-experiment")
mlflow.set_experiment("mlflow-experiment")
mlflow_run = mlflow.start_run()
Valor conectado Código de exemplo Observações
Registrar um valor numérico (int ou float) mlflow.log_metric('my_metric', 1)
Registrar um valor booliano mlflow.log_metric('my_metric', 0) 0 = True, 1 = False
Registrar uma cadeia de caracteres mlflow.log_text('foo', 'my_string') Registrado como um artefato
Registrar métricas numpy ou objetos de imagem PIL mlflow.log_image(img, 'figure.png')
Registrar arquivo de imagem ou gráfico de matlotlib mlflow.log_figure(fig, "figure.png")

Exibir métricas de execução por meio do SDK

Você pode exibir as métricas de um modelo treinado usando run.get_metrics().

from azureml.core import Run
run = Run.get_context()
run.log('metric-name', metric_value)

metrics = run.get_metrics()
# metrics is of type Dict[str, List[float]] mapping metric names
# to a list of the values for that metric in the given run.

metrics.get('metric-name')
# list of metrics in the order they were recorded

Você também pode acessar as informações de execução usando o MLflow por meio das propriedades de dados e informações do objeto de execução. Consulte a documentação do objeto MLflow.entities.Run para obter mais informações.

Depois que a execução for concluída, você poderá recuperá-la usando o MlFlowClient().

from mlflow.tracking import MlflowClient

# Use MlFlow to retrieve the run that was just completed
client = MlflowClient()
finished_mlflow_run = MlflowClient().get_run(mlflow_run.info.run_id)

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

metrics = finished_mlflow_run.data.metrics
tags = finished_mlflow_run.data.tags
params = finished_mlflow_run.data.params

Observação

O dicionário de métricas em mlflow.entities.Run.data.metrics apenas retorna o valor registrado mais recentemente para um determinado nome de métrica. Por exemplo, se você registrar, em ordem, 1, depois 2, depois 3, depois 4 para uma métrica chamada sample_metric, somente 4 estará presente no dicionário de métricas para sample_metric.

Para obter todas as métricas registradas para um nome de métrica específico, você pode usar MlFlowClient.get_metric_history().

Exibir métricas de execução na interface do usuário do Studio

Você pode procurar os registros de execução concluídos no Estúdio do Azure Machine Learning, incluindo as métricas registradas.

Navegue até a guia Experimentos. Para exibir todas as suas execuções no seu espaço de trabalho em Experimentos, selecione a guia Todas as execuções. Você pode fazer uma busca detalhada por execuções para experimentos específicos aplicando o filtro Experimento na barra de menus superior.

Para a exibição de Experimento individual, selecione a guia Todos os experimentos. No painel de execução do experimento, você pode ver as métricas e os logs acompanhados para cada execução.

Você também pode editar a tabela de lista de execução para selecionar várias execuções e exibir o valor mínimo, máximo ou registrado por último para suas execuções. Personalize seus gráficos para comparar os valores de métricas registrados e as agregações entre várias execuções. Você pode plotar várias métricas no eixo y do gráfico e personalizar o eixo x para plotar suas métricas registradas.

Exibir e baixar arquivos de log para uma execução

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 até uma execução específica para exibir seus logs e saídas:

  1. Navegue até a guia Experimentos.
  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 Baixar

Screenshot of Output and logs section of a run.

pasta user_logs

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

pasta system_logs

Essa pasta contém os logs gerados pelo Azure Machine Learning e será fechada por padrão. Os logs gerados pelo sistema são agrupados em diferentes pastas com base na fase do trabalho no runtime.

Outras pastas

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

O Azure Machine Learning registra informações de outras 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 na solução.

Sessão de log interativo

As sessões de log interativo normalmente são usadas em ambientes de notebook. O método Experiment.start_logging() inicia uma sessão de log interativo. Qualquer métrica registrada em log durante a sessão é adicionada ao registro de execução no experimento. O método run.complete() encerra as sessões e marca a execução como concluída.

Logs do ScriptRun

Nesta seção, você aprenderá a adicionar o código de log dentro de execuções criadas durante a configuração do ScriptRunConfig. Use a classe ScriptRunConfig para encapsular scripts e ambientes de execuções repetíveis. Use também essa opção para mostrar um widget de visual do Jupyter Notebooks para monitoramento.

Este exemplo executa uma limpeza de parâmetro em valores alfa e captura os resultados usando o método run.log().

  1. Crie um script de treinamento que inclua a lógica de log, train.py.

    # Copyright (c) Microsoft. All rights reserved.
# Licensed under the MIT license.

from sklearn.datasets import load_diabetes
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from azureml.core.run import Run
import os
import numpy as np
import mylib
# sklearn.externals.joblib is removed in 0.23
try:
    from sklearn.externals import joblib
except ImportError:
    import joblib

os.makedirs('./outputs', exist_ok=True)

X, y = load_diabetes(return_X_y=True)

run = Run.get_context()

X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size=0.2,
                                                    random_state=0)
data = {"train": {"X": X_train, "y": y_train},
        "test": {"X": X_test, "y": y_test}}

# list of numbers from 0.0 to 1.0 with a 0.05 interval
alphas = mylib.get_alphas()

for alpha in alphas:
    # Use Ridge algorithm to create a regression model
    reg = Ridge(alpha=alpha)
    reg.fit(data["train"]["X"], data["train"]["y"])

    preds = reg.predict(data["test"]["X"])
    mse = mean_squared_error(preds, data["test"]["y"])
    run.log('alpha', alpha)
    run.log('mse', mse)

    model_file_name = 'ridge_{0:.2f}.pkl'.format(alpha)
    # save model in the outputs folder so it automatically get uploaded
    with open(model_file_name, "wb") as file:
        joblib.dump(value=reg, filename=os.path.join('./outputs/',
                                                     model_file_name))

    print('alpha is {0:.2f}, and mse is {1:0.2f}'.format(alpha, mse))

  2. Envie o script train.py para execução em um ambiente gerenciado pelo usuário. Toda a pasta de script é enviada para treinamento.

    from azureml.core import ScriptRunConfig

src = ScriptRunConfig(source_directory='./scripts', script='train.py', environment=user_managed_env)
    run = exp.submit(src)

    O parâmetro show_output ativa o log detalhado, o que permite visualizar os detalhes do processo de treinamento, bem como as informações sobre os recursos remotos ou os destinos de computação. Use o código a seguir para ativar o log detalhado ao enviar o experimento.

    run = exp.submit(src, show_output=True)

    É possível usar o mesmo parâmetro na função wait_for_completion na execução resultante.

    run.wait_for_completion(show_output=True)

Log nativo do Python

Alguns logs do SDK poderão conter um erro que instrui você a definir o nível de registros em log como DEBUG. Para definir o nível de log, adicione o seguinte código ao script.

import logging
logging.basicConfig(level=logging.DEBUG)

Outras fontes de registro em log

O Azure Machine Learning também pode registrar em log informações de outras fontes durante o treinamento, como execuções de machine learning automatizado ou contêineres do Docker que executam os trabalhos. Esses logs não são documentados, mas se você enfrentar problemas e entrar em contato com o Suporte da Microsoft, eles poderão usar esses logs na solução de problemas.

Para obter informações sobre como registrar métricas em log no designer do Azure Machine Learning, confira Como registrar métricas em log no designer

Blocos de anotações de exemplo

Os seguintes blocos de anotações demonstram conceitos neste artigo:

Saiba como executar notebooks seguindo o artigo Usar os notebooks do Jupyter para explorar esse serviço.

Próximas etapas

Confira estes artigos para saber mais sobre como usar o Azure Machine Learning: