Visualizzare i processi e le metriche dell'esperimento con TensorBoard e Azure Machine Learning

SI APPLICA A: Python SDK azureml v1

Questo articolo illustra come visualizzare i processi e le metriche dell'esperimento in TensorBoard usando il pacchetto tensorboard nell'SDK principale di Azure Machine Learning. Una volta esaminati i processi dell'esperimento, è possibile ottimizzare e ripetere il training dei modelli di Machine Learning.

TensorBoard è una famiglia di applicazioni Web che consente di ispezionare e comprendere la struttura e le prestazioni degli esperimenti.

Il modo in cui avviare TensorBoard con gli esperimenti di Azure Machine Learning varia in base al tipo di esperimento:

• Se l'esperimento genera in modo nativo file di log utilizzabili da TensorBoard, ad esempio esperimenti di PyTorch, Chainer e TensorFlow, è possibile avviare TensorBoard direttamente dalla cronologia dei processi dell'esperimento.

• Per gli esperimenti che non restituiscono in modo nativo file utilizzabili da TensorBoard, ad esempio esperimenti di Scikit-learn o Azure Machine Learning, usare il metodo export_to_tensorboard() per esportare le cronologie dei processi come log di TensorBoard e avviare TensorBoard da tali log.

Prerequisiti

• Per avviare TensorBoard e visualizzare le cronologie dei processi degli esperimenti, è necessario aver abilitato in precedenza la registrazione per tenere traccia delle metriche e delle prestazioni.
• Il codice di questo documento può essere eseguito in uno degli ambienti seguenti:
  • Istanza di calcolo di Azure Machine Learning: nessun download o installazione necessaria
    • Completare Creare risorse per iniziare per creare un server notebook dedicato precaricato con l'SDK e il repository di esempio.
    • Nella cartella di esempi del server notebook sono disponibili due notebook completati ed espansi in queste directory:
      • 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
  • Server di notebook Jupyter personale
    • Installare Azure Machine Learning SDK con l'aggiunta di tensorboard
    • Creare un'area di lavoro di Azure Machine Learning.
    • Creare un file di configurazione dell'area di lavoro.

Opzione 1: Visualizzare la cronologia dei processi direttamente in TensorBoard

Questa opzione è valida per gli esperimenti che restituiscono in modo nativo i file di log utilizzabili da TensorBoard, ad esempio gli esperimenti di PyTorch, Chainer e TensorFlow. Se questo non è il caso dell'esperimento, usare invece il metodo export_to_tensorboard().

Il codice di esempio seguente usa l'esperimento demo MNIST del repository di TensorFlow in una destinazione di calcolo remota, l'ambiente di calcolo di Machine Learning. Successivamente, verrà configurato e avviato un processo per il training del modello TensorFlow, quindi si avvierà TensorBoard per questo esperimento di TensorFlow.

Impostare il nome dell'esperimento e creare la cartella di progetto

Assegnare un nome all'esperimento e creare la relativa cartella.

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)

Scaricare il codice dell'esperimento demo di TensorFlow

Il repository di TensorFlow include una demo MNIST con una vasta strumentazione di TensorBoard. Non è necessario modificare il codice di questa demo per l'uso con Azure Machine Learning. Nel codice seguente il codice MNIST viene scaricato e salvato nella cartella dell'esperimento appena creata.

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)

Si noti che il file di codice MNIST, mnist_with_summaries.py, include righe che richiamano tf.summary.scalar(), tf.summary.histogram(), tf.summary.FileWriter() e così via. Questi metodi raggruppano, registrano e contrassegnano le metriche chiave degli esperimenti nella cronologia processo. tf.summary.FileWriter() è particolarmente importante in quanto serializza i dati delle metriche registrate dell'esperimento, consentendo a TensorBoard di generare le relative visualizzazioni.

Configurare l'esperimento

Di seguito si configura l'esperimento e si impostano le directory per i log e i dati. Questi log verranno caricati nella cronologia processo, a cui TensorBoard accede in un secondo momento.

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)

Creare un cluster per l'esperimento

Per questo esperimento viene creato un cluster AmlCompute. Tuttavia gli esperimenti possono essere creati in qualsiasi ambiente ed è comunque possibile avviare TensorBoard per la cronologia dei processi dell'esperimento.

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())

Configurare e inviare un processo di training

Configurare un processo di training creando un oggetto 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)

Avviare TensorBoard

È possibile avviare TensorBoard durante o dopo il completamento dell'esecuzione. Nell'esempio seguente viene creata un'istanza dell'oggetto TensorBoard, tb, che acquisisce la cronologia processo dell'esperimento caricata in job e avvia TensorBoard con il metodo start().

Il costruttore TensorBoard acquisisce un array di processi, per cui occorre accertarsi di passarlo come array a elemento singolo.

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()

Opzione 2: Esportare la cronologia come log per la visualizzazione in TensorBoard

Il codice seguente configura un esperimento di esempio, avvia il processo di registrazione usando le API della cronologia processo di Azure Machine Learning ed esporta la cronologia processo dell'esperimento in log utilizzabili da TensorBoard per la visualizzazione.

Configurare l'esperimento

Il codice seguente configura un nuovo esperimento e assegna alla directory del processo il nome 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()

Qui viene caricato il set di dati sul diabete, ovvero un piccolo set di dati predefinito incluso in Scikit-learn, e lo divide in set di test e di training.

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}
}

Eseguire l'esperimento e registrare le metriche

Per questo codice, viene eseguito il training di un modello di regressione lineare e vengono registrate le metriche chiave, ovvero il coefficiente alfa, alpha, e l'errore quadratico medio, mse, nella cronologia di esecuzione.

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)

Esportare processi in TensorBoard

Con il metodo export_to_tensorboard() dell'SDK, è possibile esportare la cronologia processo dell'esperimento di Azure Machine Learning nei log di TensorBoard, in modo da poterli visualizzare tramite TensorBoard.

Nel codice seguente viene creata la cartella logdir nella directory di lavoro corrente. In questa cartella verranno esportati la cronologia processo dell'esperimento e i log di root_run, quindi il processo verrà contrassegnato come completato.

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()

Avviare e arrestare TensorBoard

Una volta esportata la cronologia processo per questo esperimento, è possibile avviare TensorBoard con il metodo 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()

Al termine, assicurarsi di chiamare il metodo stop() dell'oggetto TensorBoard. In caso contrario, TensorBoard continuerà a essere eseguito fino a quando non si arresta il kernel del notebook.

tb.stop()

Passaggi successivi

In questa procedura sono stati creati due esperimenti ed è stato illustrato come avviare TensorBoard per le relative cronologie processo per identificare potenziali aree di ottimizzazione e ripetizione del training.

• Se si è soddisfatti del modello, procedere con l'articolo Come distribuire un modello.
• Altre informazioni sull'ottimizzazione degli iperparametri.