Visualize trabalhos e métricas de experimentos com o TensorBoard e o Azure Machine Learning

APLICA-SE ASDK do Python azureml v1

Neste artigo, você aprenderá a exibir seus trabalhos e métricas de experimentos no TensorBoard usando o tensorboardpacote no SDK do Azure Machine Learning principal. Depois de inspecionar seus trabalhos de experiência, você pode ajustar e treinar melhor seus modelos de aprendizado de máquina.

O TensorBoard é um pacote de aplicativos Web para inspecionar e compreender a estrutura e o desempenho dos experimentos.

O TensorBoard é iniciado de maneira diferente de acordo com o tipo do experimento do Azure Machine Learning:

  • Se o seu experimento gerar arquivos de log que são consumíveis pelo TensorBoard, como experimentos PyTorch, Chainer e TensorFlow, você poderá iniciar o TensorBoard diretamente do histórico de trabalhos do experimento.

  • Para experimentos que não geram nativamente arquivos consumíveis do TensorBoard, como experimentos Scikit-learn ou Azure Machine Learning, use o export_to_tensorboard()método para exportar os históricos de trabalho como logs do TensorBoard e inicie o TensorBoard a partir daí.

Dica

Este documento oferece informações principalmente para cientistas de dados e desenvolvedores que querem monitorar o processo de treinamento de modelo. Se você for um administrador 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 Monitoring Azure Machine Learning.

Pré-requisitos

  • Para iniciar o TensorBoard e visualizar seus históricos de jobs de experimentos, seus experimentos precisam ter o registro ativado anteriormente para rastrear suas métricas e desempenho.
  • O código neste documento pode ser executado nos seguintes ambientes:

Opção 1: exibir diretamente o histórico de trabalho no TensorBoard

Essa opção funciona para experimentos que geram nativamente os arquivos de log consumíveis pelo TensorBoard, como experimentos do PyTorch, Chainer e TensorFlow. Se esse não for o caso do seu experimento, use o método export_to_tensorboard().

O código de exemplo a seguir usa o teste de demonstração do MNIST do repositório do TensorFlow em um destino de computação remoto, Computação do Machine Learning. Em seguida, configuraremos e iniciaremos um trabalho para treinamento do modelo do TensorFlow e, em seguida, iniciaremos o TensorBoard nesse experimento do TensorFlow.

Definir o nome do experimento e criar a pasta do projeto

Aqui, nomeamos o experimento e criamos a pasta dele.

from os import path, makedirs
experiment_name = 'tensorboard-demo'

# experiment folder
exp_dir = './sample_projects/' + experiment_name

if not path.exists(exp_dir):
    makedirs(exp_dir)

Baixar o código do experimento de demonstração do TensorFlow

O repositório de TensorFlow tem uma demonstração do MNIST com uma ampla instrumentação do TensorBoard. Não alteramos nem precisamos alterar nenhum código dessa demonstração para que funcione no Azure Machine Learning. No código a seguir, baixamos o código MNIST e o salvamos em nossa pasta de experimento recém-criada.

import requests
import os

tf_code = requests.get("https://raw.githubusercontent.com/tensorflow/tensorflow/r1.8/tensorflow/examples/tutorials/mnist/mnist_with_summaries.py")
with open(os.path.join(exp_dir, "mnist_with_summaries.py"), "w") as file:
    file.write(tf_code.text)

Em todo o arquivo de código MNIST, mnist_with_summaries.py, observe que há linhas que chamamtf.summary.scalar(), tf.summary.histogram(), tf.summary.FileWriter() etc. Esses métodos agrupam, registram e marcam as principais métricas de seus experimentos no histórico de tarefas. tf.summary.FileWriter() é especialmente importante porque serializa os dados das suas métricas de teste registradas, o que permite que o TensorBoard gere visualizações para eles.

Configurar o experimento

A seguir, configuramos nosso experimento e definimos diretórios para logs e dados. Esses logs serão carregados no histórico de tarefas, que o TensorBoard acessará posteriormente.

Observação

Para este exemplo do TensorFlow, será necessário instalar o TensorFlow no computador local. Além disso, o módulo TensorBoard (ou seja, aquele incluído com o TensorFlow) deve estar acessível ao kernel desse notebook porque o TensorBoard é executado pelo computador local.

import azureml.core
from azureml.core import Workspace
from azureml.core import Experiment

ws = Workspace.from_config()

# create directories for experiment logs and dataset
logs_dir = os.path.join(os.curdir, "logs")
data_dir = os.path.abspath(os.path.join(os.curdir, "mnist_data"))

if not path.exists(data_dir):
    makedirs(data_dir)

os.environ["TEST_TMPDIR"] = data_dir

# Writing logs to ./logs results in their being uploaded to the job history,
# and thus, made accessible to our TensorBoard instance.
args = ["--log_dir", logs_dir]

# Create an experiment
exp = Experiment(ws, experiment_name)

Criar um cluster para o experimento

Criamos um cluster AmlCompute para este experimento, mas seus experimentos podem ser criados em qualquer ambiente e você ainda pode iniciar o TensorBoard no histórico de trabalhos do experimento.

from azureml.core.compute import ComputeTarget, AmlCompute

cluster_name = "cpu-cluster"

cts = ws.compute_targets
found = False
if cluster_name in cts and cts[cluster_name].type == 'AmlCompute':
   found = True
   print('Found existing compute target.')
   compute_target = cts[cluster_name]
if not found:
    print('Creating a new compute target...')
    compute_config = AmlCompute.provisioning_configuration(vm_size='STANDARD_D2_V2', 
                                                           max_nodes=4)

    # create the cluster
    compute_target = ComputeTarget.create(ws, cluster_name, compute_config)

compute_target.wait_for_completion(show_output=True, min_node_count=None)

# use get_status() to get a detailed status for the current cluster. 
# print(compute_target.get_status().serialize())

Observação

Você pode optar por usar VMs de baixa prioridade para executar algumas ou todas as suas cargas de trabalho. Veja como criar uma VM de baixa prioridade.

Configurar e enviar trabalho de treinamento

Configure um trabalho de treinamento criando um objeto ScriptRunConfig.

from azureml.core import ScriptRunConfig
from azureml.core import Environment

# Here we will use the TensorFlow 2.2 curated environment
tf_env = Environment.get(ws, 'AzureML-TensorFlow-2.2-GPU')

src = ScriptRunConfig(source_directory=exp_dir,
                      script='mnist_with_summaries.py',
                      arguments=args,
                      compute_target=compute_target,
                      environment=tf_env)
run = exp.submit(src)

Iniciar o TensorBoard

Você pode iniciar o TensorBoard durante a execução ou após a conclusão. A seguir, criamos uma instância do objeto TensorBoard, tb, que usa o histórico de tarefas do experimento carregado no job, e inicia o TensorBoard com o método start().

O construtor TensorBoard usa uma matriz de trabalho, portanto, não esqueça de passá-lo como uma matriz de elemento único.

from azureml.tensorboard import Tensorboard

tb = Tensorboard([job])

# If successful, start() returns a string with the URI of the instance.
tb.start()

# After your job completes, be sure to stop() the streaming otherwise it will continue to run. 
tb.stop()

Observação

Embora este exemplo tenha usado o TensorFlow, o TensorBoard pode ser usado facilmente com o PyTorch ou Chainer. O TensorFlow precisa estar disponível no computador que executa o TensorBoard, mas não é necessário no computador que faz os cálculos do PyTorch ou do Chainer.

Opção 2: Exportar histórico como log para exibir no TensorBoard

O código a seguir configura um experimento de exemplo, inicia o processo de log usando as APIs de histórico de trabalho do Azure Machine Learning e exporta o histórico de trabalho do experimento em logs consumíveis pelo TensorBoard para visualização.

Configurar experimento

O código a seguir configura um novo experimento e nomeia o diretório de tarefas root_run.

from azureml.core import Workspace, Experiment
import azureml.core

# set experiment name and job name
ws = Workspace.from_config()
experiment_name = 'export-to-tensorboard'
exp = Experiment(ws, experiment_name)
root_run = exp.start_logging()

Aqui, carregamos o conjunto de dados de diabetes, um pequeno conjunto de dados interno que vem com o scikit-learn, e o dividimos em conjuntos de teste e treinamento.

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
X, y = load_diabetes(return_X_y=True)
columns = ['age', 'gender', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6']
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}
}

Executar métricas de experimento e log

Para esse código, treinamos um modelo de regressão linear e métricas de chave de log, o coeficiente alfa, alpha e o erro de quadrado médio, mse, no histórico de execuções.

from tqdm import tqdm
alphas = [.1, .2, .3, .4, .5, .6 , .7]
# try a bunch of alpha values in a Linear Regression (aka Ridge regression) mode
for alpha in tqdm(alphas):
  # create child runs and fit lines for the resulting models
  with root_run.child_run("alpha" + str(alpha)) as run:
 
   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"])
   # End train and eval

# log alpha, mean_squared_error and feature names in run history
   root_run.log("alpha", alpha)
   root_run.log("mse", mse)

Exportar trabalhos para o TensorBoard

Com o método export_to_tensorboard() do SDK, podemos exportar o histórico de trabalho de nosso experimento de aprendizado de máquina do Azure para os logs do TensorBoard, para que possamos visualizá-los por meio do TensorBoard.

No código a seguir, criamos a pasta logdir no nosso diretório de trabalho atual. Essa pasta é de onde exportaremos nosso histórico e logs de trabalhos de experiência de root_run, e em seguida, marcaremos esse trabalho como concluído.

from azureml.tensorboard.export import export_to_tensorboard
import os

logdir = 'exportedTBlogs'
log_path = os.path.join(os.getcwd(), logdir)
try:
    os.stat(log_path)
except os.error:
    os.mkdir(log_path)
print(logdir)

# export job history for the project
export_to_tensorboard(root_run, logdir)

root_run.complete()

Observação

Você também pode exportar uma execução específica para o TensorBoard especificando o nome dela export_to_tensorboard(run_name, logdir)

Iniciar e parar o TensorBoard

Depois que nosso histórico de trabalho para este experimento for exportado, podemos iniciar o TensorBoard com o método start().

from azureml.tensorboard import Tensorboard

# The TensorBoard constructor takes an array of jobs, so be sure and pass it in as a single-element array here
tb = Tensorboard([], local_root=logdir, port=6006)

# If successful, start() returns a string with the URI of the instance.
tb.start()

Quando terminar, não se esqueça de chamar o método stop() do objeto do TensorBoard. Caso contrário, o TensorBoard continuará a ser executado até que você desligue o kernel do notebook.

tb.stop()

Próximas etapas

Neste tutorial, você criou dois experimentos e aprendeu como iniciar o TensorBoard em seus históricos de trabalho para identificar áreas para possíveis ajustes e retreinamento.