Wizualizowanie zadań i metryk eksperymentów za pomocą narzędzia TensorBoard i usługi Azure Machine Edukacja

  • Artykuł

DOTYCZY: Zestaw SDK języka Python azureml w wersji 1

Z tego artykułu dowiesz się, jak wyświetlać zadania i metryki eksperymentów w narzędziu tensorboard TensorBoard przy użyciu pakietu w głównym zestawie SDK usługi Azure Machine Edukacja. Po sprawdzeniu zadań eksperymentu możesz lepiej dostosować i ponownie trenować modele uczenia maszynowego.

TensorBoard to zestaw aplikacji internetowych do sprawdzania i zrozumienia struktury eksperymentu i wydajności.

Sposób uruchamiania narzędzia TensorBoard przy użyciu usługi Azure Machine Edukacja eksperymentów zależy od typu eksperymentu:

  • Jeśli eksperyment natywnie generuje pliki dziennika, które są używane przez tensorBoard, takie jak PyTorch, Chainer i TensorFlow eksperymenty, możesz uruchomić narzędzie TensorBoard bezpośrednio z historii zadań eksperymentu.

  • W przypadku eksperymentów, które nie generują natywnie danych wyjściowych plików eksploatacyjnych TensorBoard, takich jak Scikit-learn lub Eksperymenty usługi Azure Machine Edukacja, użyj export_to_tensorboard() metody , aby wyeksportować historie zadań jako dzienniki tensorBoard i uruchomić z tego miejsca tensorBoard.

Napiwek

Informacje przedstawione w tym dokumencie są przeznaczone głównie dla analityków danych i deweloperów, którzy chcą monitorować proces trenowania modelu. Jeśli jesteś administratorem zainteresowany monitorowaniem użycia zasobów i zdarzeń z usługi Azure Machine Edukacja, takich jak limity przydziału, ukończone zadania szkoleniowe lub ukończone wdrożenia modelu, zobacz Monitorowanie usługi Azure Machine Edukacja.

Wymagania wstępne

  • Aby uruchomić narzędzie TensorBoard i wyświetlić historie zadań eksperymentów, eksperymenty muszą mieć wcześniej włączone rejestrowanie, aby śledzić jego metryki i wydajność.
  • Kod w tym dokumencie można uruchomić w jednym z następujących środowisk:
    • Wystąpienie obliczeniowe usługi Azure Machine Edukacja — brak pobierania ani instalacji
      • Ukończ tworzenie zasobów, aby rozpocząć tworzenie dedykowanego serwera notesu wstępnie załadowanego przy użyciu zestawu SDK i przykładowego repozytorium.
      • W folderze samples na serwerze notesów znajdź dwa ukończone i rozwinięte notesy, przechodząc do następujących katalogów:
        • Zestaw SDK w wersji 1 > how-to-use-azureml > track-and-monitor-experiments > tensorboard export-run-history-to-tensorboard >> export-run-history-to-tensorboard.ipynb
        • Zestaw SDK w wersji 1 > how-to-use-azureml > track-and-monitor-experiments > tensorboard tensorboard > tensorboard.ipynb >
    • Własny serwer notesu Juptyer

Opcja 1. Bezpośrednie wyświetlanie historii zadań w narzędziu TensorBoard

Ta opcja działa w przypadku eksperymentów, które natywnie wyprowadza pliki dziennika eksploatacyjne przez tensorBoard, takie jak PyTorch, Chainer i TensorFlow eksperymenty. Jeśli tak nie jest w przypadku eksperymentu, użyj export_to_tensorboard() metody .

Poniższy przykładowy kod używa eksperymentu demonstracyjnego MNIST z repozytorium TensorFlow w zdalnym obiekcie docelowym obliczeniowym azure Machine Edukacja Compute. Następnie skonfigurujemy i uruchomimy zadanie trenowania modelu TensorFlow, a następnie uruchomimy tensorBoard względem tego eksperymentu TensorFlow.

Ustawianie nazwy eksperymentu i tworzenie folderu projektu

W tym miejscu nadamy eksperymentowi nazwę i utworzymy jego folder.

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)

Pobierz kod eksperymentu demonstracyjnego Biblioteki TensorFlow

Repozytorium TensorFlow ma pokaz MNIST z rozbudowaną instrumentacją TensorBoard. Nie musimy zmieniać żadnego z tego kodu demonstracyjnego, aby działał z usługą Azure Machine Edukacja. W poniższym kodzie pobierzemy kod MNIST i zapiszemy go w nowo utworzonym folderze eksperymentu.

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)

W całym pliku kodu MNIST, mnist_with_summaries.py, zwróć uwagę, że istnieją wiersze, które nazywają tf.summary.scalar(), tf.summary.histogram(), tf.summary.FileWriter() itp. Te metody grupują, rejestrują i tagują kluczowe metryki eksperymentów w historii zadań. Jest tf.summary.FileWriter() to szczególnie ważne, ponieważ serializuje dane z zarejestrowanych metryk eksperymentu, co pozwala tensorBoard na generowanie wizualizacji poza nimi.

Konfigurowanie eksperymentu

W poniższym artykule skonfigurujemy eksperyment i skonfigurujemy katalogi dla dzienników i danych. Te dzienniki zostaną przekazane do historii zadań, do której uzyskuje się później dostęp tensorBoard.

Uwaga

W tym przykładzie TensorFlow należy zainstalować bibliotekę TensorFlow na komputerze lokalnym. Ponadto moduł TensorBoard (czyli ten dołączony do biblioteki TensorFlow) musi być dostępny dla jądra tego notesu, ponieważ maszyna lokalna uruchamia narzędzie 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)

Tworzenie klastra na potrzeby eksperymentu

Utworzymy klaster AmlCompute dla tego eksperymentu, jednak eksperymenty można utworzyć w dowolnym środowisku i nadal można uruchomić narzędzie TensorBoard względem historii zadań eksperymentu.

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

Konfigurowanie i przesyłanie zadania szkoleniowego

Skonfiguruj zadanie trenowania, tworząc obiekt 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)

Uruchamianie narzędzia TensorBoard

Możesz uruchomić narzędzie TensorBoard podczas uruchamiania lub po jego zakończeniu. W poniższej sekcji utworzymy wystąpienie obiektu TensorBoard , tbktóre pobiera historię zadań eksperymentu załadowaną w elememencie job, a następnie uruchamia tensorBoard za pomocą start() metody .

Konstruktor TensorBoard przyjmuje tablicę zadań, dlatego upewnij się, że i przekaż go jako tablicę z jednym elementem.

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

Uwaga

W tym przykładzie użyto biblioteki TensorFlow, jednak tensorBoard może być używany tak łatwo, jak w przypadku biblioteki PyTorch lub Chainer. TensorFlow musi być dostępny na maszynie z uruchomionym programem TensorBoard, ale nie jest konieczne na maszynie wykonującej obliczenia PyTorch lub Chainer.

Opcja 2. Eksportowanie historii jako dziennika w celu wyświetlenia w tablicy TensorBoard

Poniższy kod konfiguruje przykładowy eksperyment, rozpoczyna proces rejestrowania przy użyciu interfejsów API historii zadań usługi Azure Machine Edukacja i eksportuje historię zadań eksperymentu do dzienników używanych przez tensorBoard do wizualizacji.

Konfigurowanie eksperymentu

Poniższy kod konfiguruje nowy eksperyment i nazywa katalog root_runzadań .

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

W tym miejscu załadujemy zestaw danych diabetes — wbudowany mały zestaw danych dostarczany z zestawem scikit-learn i podzielimy go na zestawy testowe i szkoleniowe.

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

Uruchamianie metryk eksperymentu i dziennika

W tym kodzie trenujemy model regresji liniowej i metryki klucza dziennika, współczynnik alfa, alphai błąd średniokwadratowy, msew historii uruchamiania.

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)

Eksportowanie zadań do narzędzia TensorBoard

Za pomocą metody export_to_tensorboard() zestawu SDK możemy wyeksportować historię zadań eksperymentu uczenia maszynowego platformy Azure do dzienników biblioteki TensorBoard, abyśmy mogli je wyświetlić za pomocą narzędzia TensorBoard.

W poniższym kodzie utworzymy folder logdir w bieżącym katalogu roboczym. W tym folderze wyeksportujemy historię zadań eksperymentu i dzienniki z root_run , a następnie oznaczymy to zadanie jako ukończone.

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

Uwaga

Możesz również wyeksportować określony przebieg do narzędzia TensorBoard, określając nazwę przebiegu export_to_tensorboard(run_name, logdir)

Uruchamianie i zatrzymywanie narzędzia TensorBoard

Po wyeksportowaniu historii zadań dla tego eksperymentu możemy uruchomić narzędzie TensorBoard za pomocą metody 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()

Po zakończeniu pamiętaj, aby wywołać metodę stop() obiektu TensorBoard. W przeciwnym razie tensorBoard będzie nadal działać do momentu zamknięcia jądra notesu.

tb.stop()

Następne kroki

W tym przewodniku utworzyliśmy dwa eksperymenty i dowiedzieliśmy się, jak uruchomić narzędzie TensorBoard w swoich historiach zadań, aby zidentyfikować obszary potencjalnego dostrajania i ponownego trenowania.