Memvisualisasikan metrik dan pekerjaan eksperimen dengan TensorBoard dan Azure Machine Learning

  • Artikel

BERLAKU UNTUK:SDK Python azureml v1

Dalam artikel ini, pelajari cara menampilkan metrik dan pekerjaan eksperimen Anda di TensorBoard menggunakan tensorboard paket di Azure Machine Learning SDK utama. Setelah memeriksa pekerjaan eksperimen, Anda dapat menyetel dan melatih kembali model pembelajaran mesin Anda secara lebih baik.

TensorBoard adalah serangkaian aplikasi web untuk memeriksa dan memahami struktur dan kinerja eksperimen Anda.

Cara Anda meluncurkan TensorBoard dengan eksperimen Azure Machine Learning tergantung pada jenis eksperimen:

  • Jika eksperimen Anda secara native menghasilkan file log yang dapat dipakai oleh TensorBoard, seperti eksperimen PyTorch, Chainer, dan TensorFlow, Anda dapat meluncurkan TensorBoard secara langsung dari riwayat pekerjaan eksperimen.

  • Untuk eksperimen yang tidak secara native menghasilkan file TensorBoard yang dapat dipakai, seperti eksperimen Scikit-learn atau Azure Machine Learning, gunakan export_to_tensorboard() metode untuk mengekspor riwayat pekerjaan sebagai log TensorBoard dan meluncurkan TensorBoard dari sana.

Tip

Informasi dalam dokumen ini terutama untuk ilmuwan data dan pengembang yang ingin memantau proses pelatihan model. Jika Anda adalah seorang administrator yang tertarik untuk memantau penggunaan sumber daya dan peristiwa dari Azure Machine Learning, seperti kuota, tugas pelatihan yang telah diselesaikan, atau penyebaran model yang telah diselesaikan, lihat Memantau Azure Machine Learning.

Prasyarat

  • Untuk meluncurkan TensorBoard dan melihat riwayat pekerjaan eksperimen, eksperimen Anda harus mengaktifkan pencatatan sebelumnya untuk melacak metrik dan performanya.
  • Kode dalam dokumen ini dapat dijalankan di salah satu lingkungan berikut:
    • Instans komputasi Azure Pembelajaran Mesin - tidak ada unduhan atau penginstalan yang diperlukan
      • Selesaikan Buat sumber daya untuk mulai membuat server notebook khusus yang telah dimuat sebelumnya dengan SDK dan repositori sampel.
      • Di folder sampel di server buku catatan, temukan dua buku catatan yang telah selesai dan diperluas dengan menavigasi ke direktori ini:
        • 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
    • Server notebook Juptyer Anda sendiri

Opsi 1: Melihat langsung riwayat pekerjaan di TensorBoard

Opsi ini berfungsi untuk eksperimen yang secara asli menghasilkan file log yang dapat dikonsumsi oleh TensorBoard, seperti eksperimen PyTorch, Chainer, dan TensorFlow. Jika itu bukan kasus eksperimen Anda, gunakan export_to_tensorboard() metode sebagai gantinya.

Contoh kode berikut menggunakan eksperimen demo MNIST dari repositori TensorFlow dalam target komputasi jarak jauh, Azure Machine Learning Compute. Selanjutnya, kita akan mengonfigurasikan dan memulai pekerjaan untuk melatih model TensorFlow, lalu memulai TensorBoard untuk eksperimen TensorFlow ini.

Mengatur nama eksperimen dan membuat folder proyek

Di sini kita menamai eksperimen dan membuat foldernya.

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)

Unduh kode eksperimen demo TensorFlow

Repositori TensorFlow memiliki demo MNIST dengan instrumentasi TensorBoard yang luas. Kita tidak, juga tidak perlu, mengubah kode demo ini agar berfungsi dengan Azure Machine Learning. Dalam kode berikut, kita mengunduh kode MNIST dan menyimpannya di folder eksperimen yang baru dibuat.

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)

Di sepanjang file kode MNIST, mnist_with_summaries.py, perhatikan bahwa ada baris yang memanggil tf.summary.scalar(), tf.summary.histogram(), tf.summary.FileWriter(), dll. Metode ini mengelompokkan, mencatat, dan menandai metrik utama eksperimen Anda ke dalam riwayat pekerjaan. tf.summary.FileWriter() sangat penting karena dapat menserialisasikan data dari metrik eksperimen Anda yang tercatat, yang memungkinkan TensorBoard untuk menghasilkan visualisasi dari sana.

Mengonfigurasi eksperimen

Dalam hal berikut, kita mengonfigurasi eksperimen dan menyiapkan direktori untuk log dan data. Log ini akan diunggah ke riwayat pekerjaan, yang akan diakses TensorBoard nanti.

Catatan

Untuk contoh TensorFlow ini, Anda harus menginstal TensorFlow di mesin lokal Anda. Selanjutnya, modul TensorBoard (yaitu, yang disertakan dengan TensorFlow) harus dapat diakses oleh kernel notebook ini, karena mesin lokal adalah mesin yang menjalankan 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)

Membuat klaster untuk eksperimen Anda

Kita membuat kluster AmlCompute untuk eksperimen ini, tetapi eksperimen Anda dapat dibuat di lingkungan apa pun dan Anda tetap dapat meluncurkan TensorBoard di riwayat pekerjaan eksperimen.

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

Mengonfigurasikan dan mengirimkan pekerjaan pelatihan

Mengonfigurasi tugas pelatihan dengan membuat objek 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)

Meluncurkan TensorBoard

Anda dapat meluncurkan TensorBoard selama penjalanan atau setelah selesai. Dalam hal berikut, kita membuat instans objek TensorBoard, tb, yang mengambil riwayat pekerjaan eksperimen yang dimuat dalam job, lalu meluncurkan TensorBoard dengan metode start().

Konstruktor TensorBoard mengambil berbagai array pekerjaan, jadi pastikan dan teruskan sebagai array elemen tunggal.

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

Catatan

Meskipun contoh ini menggunakan TensorFlow, TensorBoard dapat digunakan dengan mudah menggunakan PyTorch atau Chainer. TensorFlow harus tersedia pada mesin yang menjalankan TensorBoard, tetapi tidak diperlukan pada mesin yang melakukan komputasi PyTorch atau Chainer.

Opsi 2: Mengekspor riwayat sebagai log untuk dilihat di TensorBoard

Kode berikut menyiapkan eksperimen sampel, memulai proses pengelogan menggunakan API riwayat pekerjaan Azure Machine Learning, dan mengekspor riwayat pekerjaan eksperimen ke dalam log yang dapat dipakai oleh TensorBoard untuk visualisasi.

Menyiapkan eksperimen

Kode berikut menyiapkan eksperimen baru dan menamai direktori pekerjaan 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()

Di sini kita memuat dataset diabetes-- dataset kecil bawaan yang dilengkapi dengan scikit-learn, dan membaginya menjadi rangkaian tes dan pelatihan.

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

Menjalankan metrik eksperimen dan log

Untuk kode ini, kita melatih model regresi linear dan metrik kunci log, koefisien alfa, alpha, dan rata-rata kesalahan kuadrat, mse, dalam riwayat jalan.

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)

Mengekspor pekerjaan ke TensorBoard

Dengan metode SDK export_to_tensorboard(), kita dapat mengekspor riwayat pekerjaan eksperimen pembelajaran mesin Azure ke dalam log TensorBoard, sehingga kita dapat melihatnya melalui TensorBoard.

Dalam kode berikut, kita membuat folder logdir di direktori kerja saat ini. Folder ini adalah tempat kita akan mengekspor riwayat pekerjaan eksperimen dan log dari root_run lalu menandai pekerjaan tersebut sebagai selesai.

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

Catatan

Anda juga dapat mengekspor eksekusi tertentu ke TensorBoard dengan menentukan nama eksekusi export_to_tensorboard(run_name, logdir)

Memulai dan menghentikan TensorBoard

Setelah riwayat pekerjaan untuk eksperimen ini diekspor, kita dapat meluncurkan TensorBoard dengan metode 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()

Setelah selesai, pastikan untuk memanggil metode stop() di objek TensorBoard. Jika tidak, TensorBoard akan terus berjalan sampai Anda mematikan kernel notebook.

tb.stop()

Langkah berikutnya

Dalam petunjuk ini, Anda menciptakan dua eksperimen dan mempelajari cara meluncurkan TensorBoard terhadap riwayat jalannya untuk mengidentifikasi area potensi penyetelan dan pelatihan ulang.