Share via

Visualisieren Sie Experiment-Aufträge und Metriken mit TensorBoard und Azure Machine Learning

  • Artikel

GILT FÜR:Python SDK azureml v1

In diesem Artikel erfahren Sie, wie Sie Ihre Experiment-Aufträge und Metriken in TensorBoard mithilfe des tensorboard-Pakets im Azure Machine Learning-Haupt-SDK anzeigen. Sobald Sie Ihre Experiment-Aufträge überprüft haben, können Sie Ihre Machine Learning-Modelle besser optimieren und erneut trainieren.

TensorBoard ist eine Sammlung von Webanwendungen zur Überprüfung und zum Verständnis Ihrer Experimentstruktur und -leistung.

Wie Sie TensorBoard mit Azure Machine Learning-Experimenten starten, hängt von der Art des Experiments ab:

  • Wenn Ihr Experiment nativ Protokolldateien ausgibt, die von TensorBoard verwendet werden können, z.B. PyTorch-, Chainer- und TensorFlow-Experimente, können Sie TensorBoard direkt aus dem Auftragsverlauf des Experiments starten.

  • Verwenden Sie für Experimente, die keine verbrauchbaren TensorBoard-Dateien nativ ausgeben, wie z.B. Scikit-learn- oder Azure Machine Learning-Experimente, die export_to_tensorboard()-Methode zum Exportieren der Auftragsverläufe als TensorBoard-Protokolle und starten Sie TensorBoard von dort aus.

Tipp

Die Informationen in diesem Dokument sind hauptsächlich für Datenanalysten und Entwickler gedacht, die den Modelltrainingsprozess überwachen möchten. Wenn Sie Administrator sind und sich für die Überwachung der Ressourcennutzung und Ereignisse von Azure Machine Learning (z. B. Kontingente, abgeschlossene Trainingsaufträge oder abgeschlossene Modellimplementierungen) interessieren, helfen Ihnen die Informationen im Artikel Überwachen von Azure Machine Learning weiter.

Voraussetzungen

  • Um TensorBoard zu starten und Ihre Experiment-Auftragsverläufe anzuzeigen, müssen Ihre Experimente zuvor die Protokollierung aktiviert haben, um ihre Metriken und Leistung zu verfolgen.
  • Der Code in diesem Dokument kann in einer der folgenden Umgebungen ausgeführt werden:

Option 1: Zeigen Sie den Jobverlauf direkt in TensorBoard an

Diese Option eignet sich für Experimente, die nativ Protokolldateien ausgeben, die von TensorBoard verwendet werden können, etwa PyTorch-, Chainer- und TensorFlow-Experimente. Wenn dies bei Ihrem Experiment nicht der Fall ist, verwenden Sie stattdessen die export_to_tensorboard()-Methode.

Der folgende Beispielcode verwendet das MNIST-Demo-Experiment aus dem Repository von TensorFlow in einem Remotecomputeziel, Azure Machine Learning Compute. Als Nächstes konfigurieren und starten wir einen Job zum Trainieren des TensorFlow-Modells und starten dann TensorBoard für dieses TensorFlow-Experiment.

Festlegen des Experimentnamens und Erstellen des Projektordners

Hier benennen wir das Experiment und erstellen seinen Ordner.

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)

Herunterladen des Codes des TensorFlow-Demoexperiments

Das Repository von TensorFlow verfügt über eine MNIST-Demo mit umfangreicher TensorBoard-Instrumentierung. Es ist nicht erforderlich, irgendeine Änderung am Code dieser Demo vorzunehmen, damit er mit Azure Machine Learning funktioniert. Im folgenden Code laden wir den MNIST-Code herunter und speichern ihn in unserem neu erstellten Experimentordner.

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)

Beachten Sie in der MNIST-Codedatei „mnist_with_summaries.py“, dass es Zeilen gibt, die tf.summary.scalar(), tf.summary.histogram(), tf.summary.FileWriter() usw. aufrufen. Diese Methoden gruppieren, protokollieren und markieren Schlüsselmetriken Ihrer Experimente im Auftragsverlauf. Die tf.summary.FileWriter()-Klasse ist besonders wichtig, da sie die Daten aus Ihren protokollierten Experimentmetriken serialisiert, was es TensorBoard ermöglicht, aus ihnen Visualisierungen zu generieren.

Konfigurieren des Experiments

Im Folgenden konfigurieren wir unser Experiment und richten Verzeichnisse für Protokolle und Daten ein. Diese Protokolle werden in den Jobverlauf hochgeladen, auf den TensorBoard später zugreift.

Hinweis

Für dieses TensorFlow-Beispiel müssen Sie TensorFlow auf Ihrem lokalen Computer installieren. Außerdem muss das TensorBoard-Modul (d.h. das in TensorFlow enthaltene) für den Kernel dieses Notebooks zugänglich sein, da der lokale Computer derjenige ist, der TensorBoard ausführt.

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)

Erstellen eines Clusters für Ihr Experiment

Wir erstellen einen AmlCompute-Cluster für dieses Experiment, Ihre Experimente können jedoch in jeder Umgebung erstellt werden und Sie können TensorBoard weiterhin anhand des Experiment-Auftragsverlaufs starten.

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

Hinweis

Sie können sich dafür entscheiden, virtuelle Computer mit niedriger Priorität zu verwenden, um einige oder alle Ihre Workloads auszuführen. Weitere Informationen finden Sie unter Erstellen eines virtuellen Computers mit niedriger Priorität.

Trainingsauftrag konfigurieren und senden

Konfigurieren Sie einen Trainingsauftrag, indem Sie ein ScriptRunConfig-Objekt erstellen.

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)

Starten von TensorBoard

Sie können TensorBoard während einer Ausführung oder nach deren Abschluss starten. Im Folgenden erstellen wir eine TensorBoard-Objektinstanz, tb, die den in job geladenen Experiment-Auftragsverlauf nimmt und dann TensorBoard mit der start()-Methode startet.

Der TensorBoard-Konstruktor übernimmt ein Array von Jobs, also stellen Sie sicher, dass Sie es als Array mit einem einzigen Element übergeben.

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

Hinweis

Während in diesem Beispiel TensorFlow verwendet wurde, kann TensorBoard genauso einfach mit PyTorch oder Chainer verwendet werden. TensorFlow muss auf dem Computer, auf dem TensorBoard ausgeführt wird, verfügbar sein, ist aber auf dem Computer, der PyTorch- oder Chainer-Berechnungen durchführt, nicht erforderlich.

Option 2: Exportieren des Verlaufs als Protokoll zur Anzeige in TensorBoard

Der folgende Code richtet ein Beispielexperiment ein, beginnt den Protokollierungsprozess mithilfe der Azure Machine Learning-Auftragsverlaufs-APIs und exportiert den Experiment-Auftragsverlauf in Protokolle, die von TensorBoard zur Visualisierung verwendet werden können.

Einrichten des Experiments

Der folgende Code richtet ein neues Experiment ein und benennt das Auftragsverzeichnisroot_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 wir das Diabetes-Dataset (ein integriertes kleines Dataset, das mit Scikit-learn geliefert wird) und teilen es in Test- und Trainingssets auf.

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

Ausführen des Experiments und Protokollieren der Metriken

Für diesen Code trainieren wir ein lineares Regressionsmodell und protokollieren Schlüsselmetriken, den Alpha-Koeffizienten alpha und den mittleren quadratischen Fehler mse im Ausführungsverlauf.

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)

Exportieren von Aufträge nach TensorBoard

Mit der Methode export_to_tensorboard() des SDK können wir den Auftragsverlauf unseres Azure-Experiments für maschinelles Lernen in TensorBoard-Protokolle exportieren, damit wir sie über TensorBoard anzeigen können.

Im folgenden Code erstellen wir den Ordnerlogdir in unserem aktuellen Arbeitsverzeichnis. In diesen Ordner exportieren wir unseren Versuchsauftragsverlauf und die Protokolle von root_run und markieren diesen Auftrag dann als abgeschlossen.

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

Hinweis

Sie können eine bestimmte Ausführung auch nach TensorBoard exportieren, indem Sie den Namen der Ausführung angeben: export_to_tensorboard(run_name, logdir)

Starten und Beenden von TensorBoard

Sobald unser Jobverlauf für dieses Experiment exportiert ist, können wir TensorBoard mit der Methode start() starten.

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

Wenn Sie fertig sind, stellen Sie sicher, dass Sie die stop()-Methode des TensorBoard-Objekts aufrufen. Andernfalls wird TensorBoard weiter ausgeführt, bis Sie den Notebook-Kernel herunterfahren.

tb.stop()

Nächste Schritte

In dieser Anleitung haben Sie zwei Experimente erstellt und gelernt, wie Sie TensorBoard anhand ihres beruflichen Werdegangs starten, um Bereiche für potenzielle Optimierungen und Umschulungen zu identifizieren.