Experimenttaken en metrische gegevens visualiseren met TensorBoard en Azure Machine Learning

  • Artikel

VAN TOEPASSING OP: Python SDK azureml v1

In dit artikel leert u hoe u uw experimenttaken en metrische gegevens in TensorBoard kunt weergeven met behulp van het tensorboard pakket in de belangrijkste Azure Machine Learning SDK. Zodra u uw experimenttaken hebt geïnspecteerd, kunt u uw machine learning-modellen beter afstemmen en opnieuw trainen.

TensorBoard is een reeks webtoepassingen voor het inspecteren en begrijpen van uw experimentstructuur en prestaties.

Hoe u TensorBoard start met Azure Machine Learning-experimenten, is afhankelijk van het type experiment:

  • Als uw experiment systeemeigen logboekbestanden uitvoert die kunnen worden gebruikt door TensorBoard, zoals PyTorch-, Chainer- en TensorFlow-experimenten, kunt u TensorBoard rechtstreeks vanuit de taakgeschiedenis van het experiment starten.

  • Voor experimenten die niet systeemeigen TensorBoard-verbruiksbestanden uitvoeren, zoals Scikit-learn- of Azure Machine Learning-experimenten, gebruikt u de export_to_tensorboard() methode om de taakgeschiedenissen te exporteren als TensorBoard-logboeken en TensorBoard daar te starten.

Tip

De informatie in dit document is voornamelijk bedoeld voor gegevenswetenschappers en ontwikkelaars die het modeltrainingsproces willen bewaken. Als u een beheerder bent die geïnteresseerd is in het bewaken van resourcegebruik en gebeurtenissen van Azure Machine Learning, zoals quota, voltooide trainingstaken of voltooide modelimplementaties, raadpleegt u Bewaking van Azure Machine Learning.

Vereisten

  • Als u TensorBoard wilt starten en de geschiedenis van uw experimenttaak wilt bekijken, moeten uw experimenten logboekregistratie eerder hebben ingeschakeld om de metrische gegevens en prestaties bij te houden.
  • De code in dit document kan worden uitgevoerd in een van de volgende omgevingen:
    • Azure Machine Learning-rekenproces: er zijn geen downloads of installatie nodig
      • Voltooi Resources maken om aan de slag te gaan met het maken van een toegewezen notebookserver die vooraf is geladen met de SDK en de voorbeeldopslagplaats.
      • Zoek in de map met voorbeelden op de notebookserver twee voltooide en uitgebreide notitieblokken door naar deze mappen te navigeren:
        • 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
    • Uw eigen Juptyer Notebook-server

Optie 1: Taakgeschiedenis rechtstreeks weergeven in TensorBoard

Deze optie werkt voor experimenten die systeemeigen logboekbestanden uitvoeren die worden gebruikt door TensorBoard, zoals PyTorch-, Chainer- en TensorFlow-experimenten. Als dat niet het geval is bij uw experiment, gebruikt u in plaats daarvan de export_to_tensorboard() methode .

In de volgende voorbeeldcode wordt het MNIST-demoexperiment uit de opslagplaats van TensorFlow gebruikt in een extern rekendoel, Azure Machine Learning Compute. Vervolgens gaan we een taak configureren en starten voor het trainen van het TensorFlow-model en vervolgens TensorBoard starten met dit TensorFlow-experiment.

Experimentnaam instellen en projectmap maken

Hier noemen we het experiment en maken we de map.

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)

TensorFlow-demo-experimentcode downloaden

De opslagplaats van TensorFlow heeft een MNIST-demo met uitgebreide TensorBoard-instrumentatie. We hoeven geen code van deze demo te wijzigen zodat deze kan werken met Azure Machine Learning. In de volgende code downloaden we de MNIST-code en slaan we deze op in de zojuist gemaakte experimentmap.

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)

In het MNIST-codebestand, mnist_with_summaries.py, ziet u dat er regels zijn die aanroepen tf.summary.scalar(), tf.summary.histogram()enzovoort tf.summary.FileWriter() . Deze methoden groeperen, registreren en taggen belangrijke metrische gegevens van uw experimenten in de taakgeschiedenis. Het tf.summary.FileWriter() is vooral belangrijk omdat hiermee de gegevens van de metrische gegevens van het vastgelegde experiment worden geserialiseerd, waardoor TensorBoard visualisaties van deze gegevens kan genereren.

Experiment configureren

In het volgende configureren we ons experiment en stellen we mappen in voor logboeken en gegevens. Deze logboeken worden geüpload naar de taakgeschiedenis, waartoe TensorBoard later toegang heeft.

Notitie

Voor dit TensorFlow-voorbeeld moet u TensorFlow installeren op uw lokale computer. Verder moet de TensorBoard-module (de module die deel uitmaakt van TensorFlow) toegankelijk zijn voor de kernel van dit notebook, omdat de lokale computer TensorBoard uitvoert.

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)

Een cluster maken voor uw experiment

We maken een AmlCompute-cluster voor dit experiment, maar uw experimenten kunnen in elke omgeving worden gemaakt en u kunt TensorBoard nog steeds starten op basis van de geschiedenis van de experimenttaak.

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

Trainingstaak configureren en verzenden

Configureer een trainingstaak door een ScriptRunConfig-object te maken.

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)

TensorBoard starten

U kunt TensorBoard starten tijdens de uitvoering of nadat het is voltooid. In het volgende maken we een TensorBoard-objectexemplaren, tbwaarmee de geschiedenis van de experimenttaak in het jobobject wordt geladen en vervolgens TensorBoard wordt gestart met de start() methode.

De TensorBoard-constructor neemt een matrix met taken, dus zorg ervoor dat u deze doorgeeft als een matrix met één 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()

Notitie

Hoewel in dit voorbeeld TensorFlow wordt gebruikt, kan TensorBoard net zo eenvoudig worden gebruikt met PyTorch of Chainer. TensorFlow moet beschikbaar zijn op de computer waarop TensorBoard wordt uitgevoerd, maar is niet nodig op de computer die PyTorch- of Chainer-berekeningen uitvoert.

Optie 2: Geschiedenis exporteren als logboek om weer te geven in TensorBoard

Met de volgende code wordt een voorbeeldexperiment ingesteld, wordt het logboekregistratieproces gestart met behulp van de API's voor taakgeschiedenis van Azure Machine Learning en wordt de geschiedenis van de experimenttaak geëxporteerd naar logboeken die door TensorBoard kunnen worden gebruikt voor visualisatie.

Experiment instellen

Met de volgende code stelt u een nieuw experiment in en geeft u de taakmap root_runeen naam.

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

Hier laden we de diabetesgegevensset, een ingebouwde kleine gegevensset die wordt geleverd met scikit-learn en splitst deze in test- en trainingssets.

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

Experiment en metrische logboekgegevens uitvoeren

Voor deze code trainen we een lineair regressiemodel en logboeksleutelgegevens, de alfacoëfficiënt, alphaen gemiddelde kwadratische fout, msein de uitvoeringsgeschiedenis.

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)

Taken exporteren naar TensorBoard

Met de methode export_to_tensorboard() van de SDK kunnen we de taakgeschiedenis van ons Azure Machine Learning-experiment exporteren naar TensorBoard-logboeken, zodat we ze kunnen bekijken via TensorBoard.

In de volgende code maken we de map logdir in onze huidige werkmap. In deze map exporteren we de geschiedenis en logboeken van root_run onze experimenttaak en markeren we die taak als voltooid.

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

Notitie

U kunt ook een bepaalde uitvoering exporteren naar TensorBoard door de naam van de uitvoering op te geven export_to_tensorboard(run_name, logdir)

TensorBoard starten en stoppen

Zodra onze taakgeschiedenis voor dit experiment is geëxporteerd, kunnen we TensorBoard starten met de methode 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()

Wanneer u klaar bent, moet u de stop() methode van het TensorBoard-object aanroepen. Anders blijft TensorBoard actief totdat u de notebook-kernel afsluit.

tb.stop()

Volgende stappen

In deze procedure hebt u twee experimenten gemaakt en geleerd hoe u TensorBoard kunt starten op basis van hun taakgeschiedenissen om gebieden te identificeren voor mogelijke afstemming en hertraining.