Dela via

Visualisera experimentjobb och mått med TensorBoard och Azure Machine Learning

  • Artikel

GÄLLER FÖR: Python SDK azureml v1

I den här artikeln får du lära dig hur du visar dina experimentjobb och mått i TensorBoard med hjälp av tensorboard paketet i huvud-Azure Machine Learning SDK. När du har inspekterat dina experimentjobb kan du finjustera och träna om dina maskininlärningsmodeller.

TensorBoard är en uppsättning webbprogram för att inspektera och förstå experimentets struktur och prestanda.

Hur du startar TensorBoard med Azure Machine Learning-experiment beror på typen av experiment:

  • Om experimentet internt matar ut loggfiler som kan användas av TensorBoard, till exempel PyTorch, Chainer och TensorFlow-experiment, kan du starta TensorBoard direkt från experimentets jobbhistorik.

  • För experiment som inte matar ut tensorboard-förbrukningsbara filer, till exempel Scikit-learn eller Azure Machine Learning-experiment, använder du export_to_tensorboard() metoden för att exportera jobbhistoriken som TensorBoard-loggar och starta TensorBoard därifrån.

Dricks

Informationen i det här dokumentet är främst avsedd för dataforskare och utvecklare som vill övervaka modellträningsprocessen. Om du är administratör och är intresserad av att övervaka resursanvändning och händelser från Azure Machine Learning, till exempel kvoter, slutförda träningsjobb eller slutförda modelldistributioner, kan du läsa Övervaka Azure Machine Learning.

Förutsättningar

  • För att starta TensorBoard och visa dina experimentjobbhistorik måste experimenten tidigare ha aktiverat loggning för att spåra dess mått och prestanda.
  • Koden i det här dokumentet kan köras i någon av följande miljöer:
    • Azure Machine Learning-beräkningsinstans – inga nedladdningar eller installation krävs
      • Slutför Skapa resurser för att komma igång med att skapa en dedikerad notebook-server som är förinstallerad med SDK och exempellagringsplatsen.
      • I exempelmappen på notebook-servern hittar du två slutförda och expanderade notebook-filer genom att gå till dessa kataloger:
        • 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-experiment > tensorboard > tensorboard > tensorboard.ipynb
    • Din egen Juptyer Notebook-server

Alternativ 1: Visa jobbhistorik direkt i TensorBoard

Det här alternativet fungerar för experiment som internt matar ut loggfiler som kan användas av TensorBoard, till exempel PyTorch, Chainer och TensorFlow-experiment. Om så inte är fallet med experimentet export_to_tensorboard() använder du metoden i stället.

I följande exempelkod används MNIST-demoexperimentet från TensorFlows lagringsplats i ett fjärrberäkningsmål, Azure Machine Learning Compute. Därefter ska vi konfigurera och starta ett jobb för att träna TensorFlow-modellen och sedan starta TensorBoard mot det här TensorFlow-experimentet.

Ange experimentnamnet och skapa projektmappen

Här namnger vi experimentet och skapar dess mapp.

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)

Ladda ned TensorFlow-demoexperimentkod

TensorFlows lagringsplats har en MNIST-demo med omfattande TensorBoard-instrumentation. Vi behöver inte heller ändra någon av demokoden för att den ska fungera med Azure Machine Learning. I följande kod laddar vi ned MNIST-koden och sparar den i vår nyligen skapade experimentmapp.

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)

I MNIST-kodfilen mnist_with_summaries.py, observera att det finns rader som anropar tf.summary.scalar(), tf.summary.histogram()osv tf.summary.FileWriter() . Dessa metoder grupperar, loggar och taggar viktiga mått för dina experiment i jobbhistoriken. Är tf.summary.FileWriter() särskilt viktigt eftersom det serialiserar data från dina loggade experimentmått, vilket gör det möjligt för TensorBoard att generera visualiseringar från dem.

Konfigurera experiment

I följande konfigurerar vi vårt experiment och konfigurerar kataloger för loggar och data. Dessa loggar laddas upp till jobbhistoriken, som TensorBoard kommer åt senare.

Kommentar

I det här TensorFlow-exemplet måste du installera TensorFlow på den lokala datorn. Dessutom måste TensorBoard-modulen (dvs. den som ingår i TensorFlow) vara tillgänglig för den här notebook-filens kernel, eftersom den lokala datorn är det som kör 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)

Skapa ett kluster för experimentet

Vi skapar ett AmlCompute-kluster för det här experimentet, men dina experiment kan skapas i valfri miljö och du kan fortfarande starta TensorBoard mot experimentjobbhistoriken.

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

Konfigurera och skicka träningsjobb

Konfigurera ett träningsjobb genom att skapa ett ScriptRunConfig-objekt.

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)

Starta TensorBoard

Du kan starta TensorBoard under körningen eller när den är klar. I följande skapar vi en TensorBoard-objektinstans, tb, som tar experimentjobbhistoriken jobsom lästs in i och sedan startar TensorBoard med start() -metoden.

TensorBoard-konstruktorn tar en matris med jobb, så se till att skicka in den som en matris med ett element.

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

Kommentar

Även om det här exemplet använde TensorFlow kan TensorBoard användas lika enkelt med PyTorch eller Chainer. TensorFlow måste vara tillgängligt på datorn som kör TensorBoard, men är inte nödvändigt på den dator som utför PyTorch- eller Chainer-beräkningar.

Alternativ 2: Exportera historik som logg att visa i TensorBoard

Följande kod konfigurerar ett exempelexperiment, påbörjar loggningsprocessen med hjälp av API:erna för Azure Machine Learning-jobbhistorik och exporterar experimentjobbhistoriken till loggar som kan användas av TensorBoard för visualisering.

Konfigurera experiment

Följande kod konfigurerar ett nytt experiment och namnger jobbkatalogen 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()

Här läser vi in diabetesdatauppsättningen – en inbyggd liten datauppsättning som levereras med scikit-learn och delar upp den i test- och träningsuppsättningar.

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

Köra experiment- och loggmått

För den här koden tränar vi en linjär regressionsmodell och loggnyckelmått, alfakoefficienten, alphaoch det genomsnittliga kvadratfelet , msei körningshistoriken.

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)

Exportera jobb till TensorBoard

Med SDK:ts export_to_tensorboard() -metod kan vi exportera jobbhistoriken för vårt Azure-maskininlärningsexperiment till TensorBoard-loggar, så att vi kan visa dem via TensorBoard.

I följande kod skapar vi mappen logdir i vår aktuella arbetskatalog. I den här mappen exporterar vi experimentjobbhistoriken och loggarna från root_run och markerar sedan jobbet som slutfört.

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

Kommentar

Du kan också exportera en viss körning till TensorBoard genom att ange namnet på körningen export_to_tensorboard(run_name, logdir)

Starta och stoppa TensorBoard

När vår jobbhistorik för det här experimentet har exporterats kan vi starta TensorBoard med metoden 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()

När du är klar ska du anropa metoden stop() för TensorBoard-objektet. Annars fortsätter TensorBoard att köras tills du stänger av notebook-kerneln.

tb.stop()

Nästa steg

I den här instruktioner skapade du två experiment och lärde dig hur du startar TensorBoard mot deras jobbhistorik för att identifiera områden för potentiell justering och omträning.