Delen via

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 gecontroleerd, kunt u uw machine learning-modellen beter afstemmen en opnieuw trainen.

TensorBoard is een suite met webtoepassingen voor het inspecteren en begrijpen van de structuur en prestaties van uw experiment.

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

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

  • Voor experimenten die geen systeemeigen tensorBoard-verbruiksbestanden uitvoeren, zoals Scikit-learn- of Azure Machine Learning-experimenten, gebruikt u de methode om de export_to_tensorboard() taakgeschiedenis als TensorBoard-logboeken te exporteren en start TensorBoard van daaruit.

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 het 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 experimenttaken wilt bekijken, moet logboekregistratie voor uw experimenten eerder zijn 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- 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 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-notebookserver

Optie 1: Taakgeschiedenis rechtstreeks weergeven in TensorBoard

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

In de volgende voorbeeldcode wordt gebruikgemaakt van het MNIST-demo-experiment uit de opslagplaats van TensorFlow in een extern rekendoel, Azure Machine Learning Compute. Vervolgens configureren en starten we een taak voor het trainen van het TensorFlow-model. Vervolgens starten we TensorBoard op basis van 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)

Experimentcode voor TensorFlow-demo downloaden

De opslagplaats van TensorFlow heeft een MNIST-demo met uitgebreide TensorBoard-instrumentatie. We hoeven de code van deze demo niet te wijzigen om deze te laten 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 , tf.summary.histogram(), tf.summary.FileWriter() enzovoort aanroepentf.summary.scalar(). Met deze methoden worden belangrijke metrische gegevens van uw experimenten gegroepeerd, gelogd en gelabeld in de taakgeschiedenis. De tf.summary.FileWriter() is vooral belangrijk omdat hiermee de gegevens van de metrische gegevens van uw geregistreerde experimenten worden geserialiseerd, waardoor TensorBoard er visualisaties van 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 is opgenomen in TensorFlow) toegankelijk zijn voor de kernel van dit notebook, omdat tensorBoard op de lokale computer wordt uitgevoerd.

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

Notitie

U kunt ervoor kiezen VM's met een lage prioriteit te gebruiken om enkele of alle workloads uit te voeren. Zie hoe u een virtuele machine met lage prioriteit kunt maken.

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 of nadat deze is voltooid. In het volgende maken we een TensorBoard-objectexemplaar, tb, dat de geschiedenis van de experimenttaak neemt die in de jobis geladen en vervolgens TensorBoard start met de start() methode .

De TensorBoard-constructor neemt een matrix met taken op, dus zorg ervoor dat deze wordt doorgegeven 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 werd 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 van de Azure Machine Learning-taakgeschiedenis en wordt de taakgeschiedenis van het experiment geëxporteerd naar logboeken die door TensorBoard kunnen worden gebruikt voor visualisatie.

Experiment instellen

Met de volgende code wordt een nieuw experiment ingesteld en wordt de taakmap een naam genoemd 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()

Hier laden we de diabetesgegevensset, een ingebouwde kleine gegevensset die wordt geleverd met scikit-learn, en splitsen we deze op 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 uitvoeren en metrische gegevens vastleggen

Voor deze code trainen we een lineair regressiemodel en registreren we belangrijke metrische gegevens, de alfacoëfficiënt, alphaen de gemiddelde kwadratische fout, mse, in 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 het Azure Machine Learning-experiment exporteren naar TensorBoard-logboeken, zodat we deze kunnen bekijken via TensorBoard.

In de volgende code maken we de map logdir in de 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 een bepaalde uitvoering ook exporteren naar TensorBoard door de naam van de uitvoering op te geven export_to_tensorboard(run_name, logdir)

TensorBoard starten en stoppen

Zodra de 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 methode stop() van het TensorBoard-object aanroepen. Anders blijft TensorBoard actief totdat u de notebookkernel afsluit.

tb.stop()

Volgende stappen

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