Sdílet prostřednictvím

Vizualizace úloh a metrik experimentů s využitím TensorBoardu a Azure Machine Learning

  • Článek

PLATÍ PRO: Python SDK azureml v1

V tomto článku se dozvíte, jak zobrazit úlohy experimentu a metriky v TensorBoardu tensorboard pomocí balíčku v hlavní sadě Azure Machine Learning SDK. Po kontrole úloh experimentu můžete lépe vyladit a přetrénovat modely strojového učení.

TensorBoard je sada webových aplikací pro kontrolu a pochopení struktury a výkonu experimentu.

Způsob spuštění TensorBoardu s experimenty Azure Machine Learning závisí na typu experimentu:

  • Pokud váš experiment nativně vypíše soubory protokolů, které jsou dostupné pomocí TensorBoardu, jako jsou experimenty PyTorch, Chainer a TensorFlow, můžete spustit TensorBoard přímo z historie úloh experimentu.

  • Pro experimenty, které nativně nevypisují spotřební soubory TensorBoardu, jako jsou experimenty Scikit-learn nebo Azure Machine Learning, použijte export_to_tensorboard() metodu k exportu historie úloh jako protokolů TensorBoardu a spuštění TensorBoardu odtud.

Tip

Informace v tomto dokumentu jsou primárně určené datovým vědcům a vývojářům, kteří chtějí monitorovat proces trénování modelu. Pokud máte zájem o monitorování využití prostředků a událostí ze služby Azure Machine Learning, jako jsou kvóty, dokončené trénovací úlohy nebo dokončená nasazení modelu, přečtěte si téma Monitorování služby Azure Machine Learning.

Požadavky

  • Pokud chcete spustit TensorBoard a zobrazit historii úloh experimentu, musí mít experimenty dříve povolené protokolování, aby bylo možné sledovat metriky a výkon.
  • Kód v tomto dokumentu lze spustit v některém z následujících prostředí:
    • Výpočetní instance Služby Azure Machine Learning – není potřeba stahovat ani instalovat
      • Dokončete vytváření prostředků, abyste mohli začít vytvářet vyhrazený server poznámkových bloků předem načtený se sadou SDK a ukázkovým úložištěm.
      • Ve složce s ukázkami na serveru poznámkového bloku najděte dva dokončené a rozbalené poznámkové bloky tak, že přejdete do těchto adresářů:
        • Sdk v1 > – postupy použití azureml > track-and-monitor-experiments > tensorboard > export-run-history-to-tensorboard > export-run-history-to-tensorboard.ipynb
        • Sdk v1 > – postupy použití azureml > track-and-monitor-experiments > tensorboard > tensorboard > tensorboard.ipynb
    • Vlastní server poznámkového bloku Juptyer

Možnost 1: Přímé zobrazení historie úloh v TensorBoardu

Tato možnost funguje u experimentů, které nativně vypisují soubory protokolů používané tensorBoardem, jako jsou PyTorch, Chainer a TensorFlow experimenty. Pokud to není případ experimentu, použijte místo toho metoduexport_to_tensorboard().

Následující ukázkový kód používá ukázkový experiment MNIST z úložiště TensorFlow ve vzdáleném cílovém výpočetním objektu Azure Machine Learning Compute. Dále nakonfigurujeme a spustíme úlohu pro trénování modelu TensorFlow a pak spustíme TensorBoard s tímto experimentem TensorFlow.

Nastavení názvu experimentu a vytvoření složky projektu

Tady pojmenujeme experiment a vytvoříme jeho složku.

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)

Stažení ukázkového kódu experimentu TensorFlow

Úložiště TensorFlow má ukázku MNIST s rozsáhlou instrumentací TensorBoardu. Pro práci se službou Azure Machine Learning nemusíme ani měnit žádný kód této ukázky. V následujícím kódu stáhneme kód MNIST a uložíme ho do nově vytvořené složky experimentu.

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)

V celém souboru kódu MNIST, mnist_with_summaries.py, všimněte si, že existují řádky, které volají tf.summary.scalar(), tf.summary.histogram()tf.summary.FileWriter() atd. Tyto metody seskupují, protokolují a označují klíčové metriky experimentů do historie úloh. To tf.summary.FileWriter() je zvlášť důležité, protože serializuje data z protokolovaných metrik experimentu, což umožňuje TensorBoard generovat vizualizace z nich.

Konfigurace experimentu

V následujícím příkladu nakonfigurujeme experiment a nastavíme adresáře pro protokoly a data. Tyto protokoly se nahrají do historie úloh, ke které tensorBoard přistupuje později.

Poznámka:

V tomto příkladu TensorFlow budete muset nainstalovat TensorFlow na místní počítač. Modul TensorBoard (to znamená ten, který je součástí TensorFlow), musí být navíc přístupný pro jádro tohoto poznámkového bloku, protože místní počítač spouští 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)

Vytvoření clusteru pro experiment

Pro tento experiment vytvoříme cluster AmlCompute, ale experimenty je možné vytvořit v libovolném prostředí a stále můžete spustit TensorBoard pro historii úloh experimentu.

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

Konfigurace a odeslání trénovací úlohy

Nakonfigurujte trénovací úlohu vytvořením objektu 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)

Spuštění TensorBoardu

TensorBoard můžete spustit během běhu nebo po jeho dokončení. V následujícím příkladu vytvoříme instanci objektu TensorBoard, tbkterá vezme historii úlohy experimentu jobnačtenou do a pak spustí TensorBoard s metodou start() .

Konstruktor TensorBoard přebírá pole úloh, proto ho nezapomeňte předat jako pole s jedním prvkem.

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

Poznámka:

I když tento příklad používá TensorFlow, TensorBoard lze použít stejně snadno s PyTorch nebo Chainer. TensorFlow musí být k dispozici na počítači, na kterém běží TensorBoard, ale na počítači, který provádí výpočty PyTorch nebo Chainer, není nutné.

Možnost 2: Export historie jako protokolu pro zobrazení v TensorBoardu

Následující kód nastaví ukázkový experiment, zahájí proces protokolování pomocí rozhraní API historie úloh Služby Azure Machine Learning a exportuje historii úloh experimentu do protokolů použitelných tensorBoardem pro vizualizaci.

Nastavení experimentu

Následující kód nastaví nový experiment a pojmenuje adresář root_runúlohy .

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

Tady načteme datovou sadu diabetes – integrovanou malou datovou sadu, která je součástí scikit-learn, a rozdělíme ji na testovací a trénovací sady.

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

Spuštění metrik experimentu a protokolů

Pro tento kód vytrénujeme lineární regresní model a metriky klíče protokolu, alfa koeficient a alphastřední kvadratická chyba v msehistorii spuštění.

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)

Export úloh do TensorBoardu

Pomocí metody export_to_tensorboard() sady SDK můžeme exportovat historii úloh experimentu azure machine learning do protokolů TensorBoardu, abychom je mohli zobrazit prostřednictvím TensorBoardu.

V následujícím kódu vytvoříme složku logdir v aktuálním pracovním adresáři. V této složce exportujeme historii a protokoly úlohy experimentu root_run a pak tuto úlohu označíme jako dokončenou.

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

Poznámka:

Konkrétní spuštění můžete také exportovat do TensorBoardu zadáním názvu spuštění. export_to_tensorboard(run_name, logdir)

Spuštění a zastavení TensorBoardu

Po exportu naší historie úloh pro tento experiment můžeme spustit TensorBoard metodou 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()

Až budete hotovi, nezapomeňte volat metodu stop() objektu TensorBoard. V opačném případě bude TensorBoard dál běžet, dokud nevypnete jádro poznámkového bloku.

tb.stop()

Další kroky

V tomto postupu jste vytvořili dva experimenty a naučili se, jak spustit TensorBoard proti historii úloh, abyste identifikovali oblasti pro potenciální ladění a opětovné natrénování.