Log & visualizar métricas e arquivos de log v1

Artigo
01/10/2024

Registre informações em tempo real usando o pacote de log padrão do Python e a funcionalidade específica do SDK do Python do Azure Machine Learning. Pode registar localmente e enviar registos para a sua área de trabalho no portal.

Os registos podem ajudá-lo a diagnosticar erros e avisos ou a acompanhar métricas de desempenho, como parâmetros e desempenho do modelo. Neste artigo, vai aprender a ativar o registo nos seguintes cenários:

Métricas de execução de log
Sessões de preparação interativas
Enviar tarefas de preparação com ScriptRunConfig
Definições de logging nativas do Python
Registo de origens adicionais

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 Aprendizado de Máquina do Azure, como cotas, execuções de treinamento concluídas ou implantações de modelo concluídas, consulte Monitorando o Aprendizado de Máquina do Azure.

Tipos de dados

Pode registar vários tipos de dados, incluindo valores escalares, listas, tabelas, imagens e diretórios, entre outros. Para obter mais informações e exemplos de código do Python para diferentes tipos de dados, veja a página de referência da classe Run.

Registrando métricas de execução

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

Valor registrado	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 única
Registre um único valor numérico com o mesmo nome de métrica usado repetidamente (como de dentro de 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 única
Registrar uma linha com 2 colunas numéricas 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 com duas variáveis
Tabela de log com 2 colunas numéricas	`run.log_table(name='Sine Wave', value=sines)`	Gráfico de linhas com duas variáveis
Imagem de registo	`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 para a execução. Estas imagens serão visíveis e comparáveis no registo de execução

Registro em log com MLflow

Recomendamos registrar seus modelos, métricas e artefatos com o MLflow, pois ele é de código aberto e suporta o modo local para a portabilidade na 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 e padrões de design do MLflow.

Certifique-se de instalar os mlflow pacotes e azureml-mlflow pip em seu espaço de trabalho.

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 registrado	Código de exemplo	Notas
Registrar um valor numérico (int ou float)	`mlflow.log_metric('my_metric', 1)`
Registrar um valor booleano	`mlflow.log_metric('my_metric', 0)`	0 = Verdadeiro, 1 = Falso
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 gráfico matlotlib ou arquivo de imagem	`mlflow.log_figure(fig, "figure.png")`

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

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

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 informações de execução usando MLflow através 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.

Após a conclusão da execução, você pode 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, parâmetros e tags 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

Nota

O dicionário de métricas em mlflow.entities.Run.data.metrics retorna apenas o valor registrado mais recentemente para um determinado nome de métrica. Por exemplo, se você registrar, na ordem, 1, depois 2, depois 3, então 4 para uma métrica chamada sample_metric, apenas 4 está 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 estúdio

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

Navegue até a guia Experimentos . Para exibir todas as suas execuções em seu espaço de trabalho em Experimentos, selecione a guia Todas as execuções . Você pode detalhar as execuções para Experimentos específicos aplicando o filtro Experiência na barra de menu superior.

Para a visualização Experimento individual, selecione a guia Todos os experimentos . No painel de execução de experimento, você pode ver métricas e logs controlados 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 último, mínimo ou máximo valor registrado para suas execuções. Personalize seus gráficos para comparar os valores de métricas registrados e agregações em várias execuções. Você pode plotar várias métricas no eixo y do gráfico e personalizar o eixo x para plotar as métricas registradas.

Ver e transferir ficheiros de registo 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 em uma execução específica para visualizar seus logs e saídas:

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

Screenshot of Output and logs section of a run.

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 logs do seu script de controle e stderr script de treinamento, um por processo. Na maioria dos casos, você monitorará os logs aqui.

system_logs pasta

Esta 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 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 IP de nó. A estrutura para cada nó é a mesma que 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 sã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.

Sessão de registo interativa

Normalmente, as sessões de registo interativas são utilizadas em ambientes de blocos de notas. O método Experiment.start_logging() inicia uma sessão de registo interativa. Todas as métricas registadas durante a sessão são adicionadas ao registo de execução na experimentação. O método run.complete() encerra as sessões e marca a execução como concluída.

Registos ScriptRun

Nesta secção, irá aprender a adicionar código de registo dentro de execuções criadas quando configuradas com ScriptRunConfig. Pode utilizar a classe ScriptRunConfig para encapsular os scripts e os ambientes para execuções repetíveis. Também pode utilizar esta opção para mostrar um widget de elemento visual de Jupyter Notebooks para monitorização.

Este exemplo realiza um varrimento de parâmetros em valores alfa e captura os resultados com o método run.log().

Crie um script de preparação que inclua a lógica de registo, 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))

Envie o script train.py a ser executado num ambiente gerido pelo utilizador. A pasta completa do script é enviada para preparação.
```
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 registo verboso, o que lhe permite ver detalhes do processo de preparação, bem como informações sobre quaisquer recursos remotos ou destinos de computação. Utilize o código seguinte para ativar o registo verboso ao enviar a experimentação.
```
run = exp.submit(src, show_output=True)
```
Também pode utilizar o mesmo parâmetro na função wait_for_completion na execução resultante.
```
run.wait_for_completion(show_output=True)
```

Registo do Python nativo

Alguns registos no SDK podem conter um erro que instrui o utilizador a definir o nível de registo como DEPURAÇÃO. Para definir o nível de registo, adicione o código seguinte ao seu script.

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

Outras fontes de registro

O Azure Machine Learning também pode registar informações de outras origens durante a preparação, como execuções de machine learning automatizado ou contentores do Docker que executam as tarefas. Estes registos não estão documentados, mas se encontrar problemas e entrar em contacto com o suporte da Microsoft, este pode utilizá-los durante a resolução de problemas.

Para obter informações sobre as métricas de registo no estruturador do Azure Machine Learning, veja Como registar métricas no estruturador

Blocos de notas de exemplo

Os blocos de notas seguintes demonstram conceitos neste artigo:

Saiba como executar blocos de notas ao seguir o artigo Utilizar blocos de notas Jupyter para explorar este serviço.

Próximos passos

Veja estes artigos para saber mais sobre como utilizar o Azure Machine Learning:

Veja um exemplo sobre como registar o melhor modelo e implementá-lo no tutorial Preparar um modelo de classificação de imagens com o Azure Machine Learning.