Partilhar via

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

  • Artigo

APLICA-SE A: Python SDK azureml v1

Neste artigo, você aprenderá a exibir seus trabalhos de experimento e métricas no TensorBoard usando o tensorboard pacote no SDK principal do Azure Machine Learning. Depois de inspecionar seus trabalhos de experimento, você pode ajustar e treinar novamente seus modelos de aprendizado de máquina.

O TensorBoard é um conjunto de aplicações web para inspecionar e compreender a estrutura e o desempenho da sua experiência.

Como você inicia o TensorBoard com experimentos do Azure Machine Learning depende do tipo de experimento:

  • Se seu experimento produz nativamente arquivos de log que são consumíveis pelo TensorBoard, como experimentos PyTorch, Chainer e TensorFlow, então você pode iniciar o TensorBoard diretamente do histórico de trabalho do experimento.

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

Gorjeta

As informações neste documento são principalmente para cientistas de dados e desenvolvedores que desejam monitorar o processo de treinamento do modelo. Se você for um administrador interessado em monitorar o uso de recursos e eventos do Aprendizado de Máquina do Azure, como cotas, trabalhos de treinamento concluídos ou implantações de modelo concluídas, consulte Monitorando o Aprendizado de Máquina do Azure.

Pré-requisitos

  • Para iniciar o TensorBoard e visualizar seus históricos de trabalho de experimento, seus experimentos precisam ter habilitado previamente o registro para acompanhar suas métricas e desempenho.
  • O código neste documento pode ser executado em qualquer um dos seguintes ambientes:
    • Instância de computação do Azure Machine Learning - sem necessidade de downloads ou instalação
      • Conclua Crie recursos para começar a criar um servidor de notebook dedicado pré-carregado com o SDK e o repositório de exemplo.
      • Na pasta de exemplos no servidor de notebook, localize dois blocos de anotações concluídos e expandidos navegando até estes diretórios:
        • SDK v1 > how-to-use-azureml > track-and-monitor-experiments > tensorboard > export-run-history-to-tensorboard > export-run-history-to-tensorboard.ipynb
        • SDK v1 > how-to-use-azureml > track-and-monitor-experiments > tensorboard tensorboard > > tensorboard.ipynb
    • Seu próprio servidor de notebook Juptyer

Opção 1: Visualizar diretamente o histórico de trabalhos no TensorBoard

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

O código de exemplo a seguir usa o experimento de demonstração MNIST do repositório do TensorFlow em um destino de computação remoto, o Azure Machine Learning Compute. Em seguida, vamos configurar e iniciar um trabalho para treinar o modelo TensorFlow e, em seguida, iniciar o TensorBoard contra esse experimento TensorFlow.

Definir o nome do experimento e criar a pasta do projeto

Aqui nomeamos o experimento e criamos sua pasta.

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 do TensorFlow tem uma demonstração MNIST com instrumentação extensiva do TensorBoard. Não alteramos, nem precisamos, nenhum código desta demonstração para que ela funcione com o 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 chamam tf.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 trabalhos. O tf.summary.FileWriter() é especialmente importante, pois serializa os dados de suas métricas de experimento registradas, o que permite que o TensorBoard gere visualizações a partir delas.

Configurar experiência

A seguir, configuramos nosso experimento e configuramos diretórios para logs e dados. Esses logs serão carregados para o histórico de trabalhos, que o TensorBoard acessa mais tarde.

Nota

Para este exemplo do TensorFlow, você precisará instalar o TensorFlow em sua máquina local. Além disso, o módulo TensorBoard (ou seja, aquele incluído no TensorFlow) deve ser acessível ao kernel deste notebook, pois a máquina local é o que executa o TensorBoard.

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 a sua experiência

Criamos um cluster AmlCompute para este experimento, no entanto, seus experimentos podem ser criados em qualquer ambiente e você ainda pode iniciar o TensorBoard contra o histórico de trabalho 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())

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)

Lançamento do TensorBoard

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

O construtor TensorBoard usa uma matriz de trabalhos, portanto, certifique-se e passe-a 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()

Nota

Enquanto este exemplo usou o TensorFlow, o TensorBoard pode ser usado facilmente com o PyTorch ou o Chainer. O TensorFlow deve estar disponível na máquina que executa o TensorBoard, mas não é necessário na máquina que faz cálculos PyTorch ou Chainer.

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

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

Configurar experiência

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

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 integrado 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 este código, treinamos um modelo de regressão linear e métricas de chave de log, o coeficiente alphaalfa e o erro quadrado médio, mseno histórico de execução.

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 trabalhos de nosso experimento de aprendizado de máquina do Azure para logs do TensorBoard, para que possamos visualizá-los via TensorBoard.

No código a seguir, criamos a pasta logdir em nosso diretório de trabalho atual. Esta pasta é de onde exportaremos nosso histórico de trabalho de experimento e logs e root_run , 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()

Nota

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

Iniciar e parar o TensorBoard

Uma vez que nosso histórico de trabalho para este experimento é 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, certifique-se de chamar o método stop() do objeto TensorBoard. Caso contrário, o TensorBoard continuará a ser executado até que você desligue o kernel do notebook.

tb.stop()

Próximos passos

Neste tutorial, você criou dois experimentos e aprendeu como lançar o TensorBoard contra seus históricos de trabalho para identificar áreas para potencial ajuste e reciclagem.