Megosztás a következőn keresztül:

Kísérleti feladatok és metrikák vizualizációja a TensorBoard és az Azure Machine Learning használatával

  • Cikk

A KÖVETKEZŐKRE VONATKOZIK: Python SDK azureml v1

Ebben a cikkben megtudhatja, hogyan tekintheti meg a kísérleti feladatokat és metrikákat a TensorBoardban a tensorboard fő Azure Machine Learning SDK csomagjával. Miután megvizsgálta a kísérleti feladatokat, jobban hangolhatja és újrataníthatja gépi tanulási modelljeit.

A TensorBoard egy webalkalmazás-csomag, a kísérlet szerkezetének és teljesítményének vizsgálatához és megértéséhez.

A TensorBoard Azure Machine Learning-kísérletekkel való elindítása a kísérlet típusától függ:

  • Ha a kísérlet natív módon kimeneteli a TensorBoard által fogyasztható naplófájlokat, például a PyTorch, a Chainer és a TensorFlow kísérleteket, akkor közvetlenül a kísérlet feladatelőzményeiből indíthatja el a TensorBoardot.

  • Az olyan kísérletek esetében, amelyek natív módon nem adnak ki TensorBoard-beli hasznosítható fájlokat, például Scikit-learn- vagy Azure Machine Learning-kísérleteket, a export_to_tensorboard() módszerrel exportálhatja a feladatelőzményeket TensorBoard-naplókként, és onnan indíthatja el a TensorBoardot.

Tipp.

A dokumentumban szereplő információk elsősorban a modell betanítási folyamatát monitorozni kívánó adattudósok és fejlesztők számára szólnak. Ha Ön olyan rendszergazda, aki az Azure Machine Learningből származó erőforrás-használatot és eseményeket, például kvótákat, befejezett betanítási feladatokat vagy befejezett modelltelepítéseket szeretne figyelni, tekintse meg az Azure Machine Learning monitorozását.

Előfeltételek

1. lehetőség: Feladatelőzmények közvetlen megtekintése a TensorBoardban

Ez a beállítás olyan kísérletekhez használható, amelyek natív módon kimenetelik a TensorBoard által fogyasztható naplófájlokat, például a PyTorch, a Chainer és a TensorFlow kísérleteket. Ha nem ez a kísérlet esete, használja inkább a metódustexport_to_tensorboard().

Az alábbi példakód a TensorFlow adattárából származó MNIST-bemutató kísérletet használja egy távoli számítási célban, az Azure Machine Learning Computeben. Ezután konfigurálunk és elindítunk egy feladatot a TensorFlow-modell betanításához, majd elindítjuk a TensorBoardot a TensorFlow-kísérlethez.

Kísérlet nevének beállítása és projektmappa létrehozása

Itt nevezzük el a kísérletet, és létrehozzuk annak mappáját.

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-bemutató kísérletkód letöltése

A TensorFlow adattára MNIST-bemutatóval rendelkezik, széles körű TensorBoard-kialakítással. Az Azure Machine Learning használatához nem módosítjuk a bemutató kódját, és nem is kell módosítani. Az alábbi kódban letöltjük az MNIST-kódot, és az újonnan létrehozott kísérletmappába mentjük.

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)

Az MNIST-kódfájlban mnist_with_summaries.py figyelje meg, hogy vannak olyan sorok, amelyek meghívják tf.summary.scalar(), tf.summary.histogram()tf.summary.FileWriter() stb. Ezek a metódusok a kísérletek fő metrikáit csoportosítják, naplózják és címkézik a feladatelőzményekbe. Ez tf.summary.FileWriter() különösen fontos, mivel szerializálja a naplózott kísérleti metrikák adatait, ami lehetővé teszi, hogy a TensorBoard vizualizációkat hozzon létre belőlük.

Kísérlet konfigurálása

Az alábbiakban konfiguráljuk a kísérletet, és beállítjuk a naplókhoz és adatokhoz tartozó könyvtárakat. Ezek a naplók fel lesznek töltve a feladatelőzményekbe, amelyeket a TensorBoard később ér el.

Feljegyzés

Ebben a TensorFlow-példában telepítenie kell a TensorFlow-t a helyi gépen. Ezenkívül a TensorBoard modulnak (vagyis a TensorFlow-hoz tartozónak) elérhetőnek kell lennie a jegyzetfüzet kerneléhez, mivel a helyi gép a TensorBoardot futtatja.

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)

Fürt létrehozása a kísérlethez

Ehhez a kísérlethez AmlCompute-fürtöt hozunk létre, de a kísérletek bármilyen környezetben létrehozhatóak, és továbbra is elindíthatja a TensorBoardot a kísérletfeladatok előzményei alapján.

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

Betanítási feladat konfigurálása és elküldése

Betanítási feladat konfigurálása ScriptRunConfig-objektum létrehozásával.

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)

A TensorBoard indítása

A TensorBoardot futtatás közben vagy a befejezés után is elindíthatja. Az alábbiakban létrehozunk egy TensorBoard objektumpéldányt, tbamely a kísérleti feladat előzményeit tölti be a jobfájlba, majd elindítja a TensorBoardot a start() metódussal.

A TensorBoard konstruktor feladattömböt vesz fel, ezért győződjön meg róla, és adja át egyelemes tömbként.

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

Feljegyzés

Bár ez a példa a TensorFlow-t használta, a TensorBoard a PyTorch vagy a Chainer használatával is egyszerűen használható. A TensorFlow-nak elérhetőnek kell lennie a TensorBoardot futtató gépen, de nem szükséges a PyTorch- vagy Chainer-számításokat végző gépen.

2. lehetőség: Az előzmények exportálása naplóként a TensorBoardban való megtekintéshez

Az alábbi kód beállít egy mintakísérletet, elindítja a naplózási folyamatot az Azure Machine Learning-feladatelőzmények API-jaival, és exportálja a kísérletfeladatok előzményeit a TensorBoard által vizualizációhoz használt naplókba.

Kísérlet beállítása

Az alábbi kód beállít egy új kísérletet, és elnevozza a feladatkönyvtárat 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()

Itt betöltjük a diabetes-adatkészletet- egy beépített kis adatkészletet, amely scikit-learn-et tartalmaz, és teszt- és betanítási csoportokra osztja.

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

Kísérlet- és naplómetrikák futtatása

Ebben a kódban betanítottunk egy lineáris regressziós modellt és naplókulcs-metrikákat, az alfa-együtthatót alphaés a középérték négyzetes hibát a msefuttatási előzményekben.

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)

Feladatok exportálása a TensorBoardba

Az SDK export_to_tensorboard() metódusával exportálhatjuk az Azure machine learning-kísérletünk feladatelőzményeit TensorBoard-naplókba, így a TensorBoardon keresztül tekinthetjük meg őket.

Az alábbi kódban létrehozzuk a mappát logdir az aktuális munkakönyvtárban. Ebben a mappában exportáljuk a kísérletfeladatok előzményeit és naplóit root_run , majd befejezettként jelöljük meg a feladatot.

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

Feljegyzés

Egy adott futtatást a TensorBoardba is exportálhat a futtatás nevének megadásával export_to_tensorboard(run_name, logdir)

TensorBoard indítása és leállítása

A kísérlethez tartozó feladatelőzmények exportálása után elindíthatjuk a TensorBoardot a start() metódussal.

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

Ha elkészült, mindenképpen hívja meg a TensorBoard objektum stop() metódusát. Ellenkező esetben a TensorBoard továbbra is futni fog, amíg le nem zárja a jegyzetfüzet kernelét.

tb.stop()

Következő lépések

Ebben az útmutatóban két kísérletet hozott létre, és megtanulta, hogyan indíthatja el a TensorBoardot a feladatelőzményeik alapján, hogy azonosítsa a lehetséges finomhangolási és áttanítási területeket.