Aracılığıyla paylaş

TensorBoard ve Azure Machine Learning ile deneme işlerini ve ölçümlerini görselleştirme

  • Makale

ŞUNUN IÇIN GEÇERLIDIR:Python SDK azureml v1

Bu makalede, ana Azure Machine Learning SDK'sında paketi kullanarak TensorBoard'da deneme işlerinizi ve ölçümlerinizi görüntülemeyi tensorboard öğreneceksiniz. Deneme işlerinizi inceledikten sonra makine öğrenmesi modellerinizi daha iyi ayarlayabilir ve yeniden eğitebilirsiniz.

TensorBoard , deneme yapınızı ve performansınızı incelemek ve anlamak için bir web uygulamaları paketidir.

Azure Machine Learning denemeleriyle TensorBoard'u nasıl başlatabileceğiniz deneme türüne bağlıdır:

  • Denemeniz PyTorch, Chainer ve TensorFlow denemeleri gibi TensorBoard tarafından tüketilebilen günlük dosyalarını yerel olarak çıkarıyorsa, TensorBoard'u doğrudan denemenin iş geçmişinden başlatabilirsiniz.

  • Scikit-learn veya Azure Machine Learning denemeleri gibi TensorBoard tüketilebilir dosyalarını yerel olarak çıkarmamış denemeler için yöntemini kullanarak export_to_tensorboard() iş geçmişlerini TensorBoard günlükleri olarak dışarı aktarın ve TensorBoard'u buradan başlatın.

İpucu

Bu belgedeki bilgiler öncelikli olarak model eğitim sürecini izlemek isteyen veri bilimciler ve geliştiriciler içindir. Azure Machine Learning'deki kotalar, tamamlanmış eğitim işleri veya tamamlanmış model dağıtımları gibi kaynak kullanımını ve olaylarını izlemek isteyen bir yöneticiyseniz bkz . Azure Machine Learning'i izleme.

Önkoşullar

  • TensorBoard'u başlatmak ve deneme işi geçmişlerinizi görüntülemek için denemelerinizin ölçümlerini ve performansını izlemek için daha önce günlüğe kaydetmeyi etkinleştirmiş olması gerekir.
  • Bu belgedeki kod aşağıdaki ortamlardan birinde çalıştırılabilir:

1. Seçenek: TensorBoard'da iş geçmişini doğrudan görüntüleme

Bu seçenek, PyTorch, Chainer ve TensorFlow denemeleri gibi TensorBoard tarafından tüketilebilen günlük dosyalarını yerel olarak veren denemeler için çalışır. Denemeniz böyle değilse, bunun yerine yöntemini kullanınexport_to_tensorboard().

Aşağıdaki örnek kod, TensorFlow'un uzak işlem hedefi olan Azure Machine Learning İşlem deposundaki MNIST tanıtım denemesini kullanır. Ardından, TensorFlow modelini eğitecek bir iş yapılandıracak ve başlatacak ve ardından tensorBoard'u bu TensorFlow denemesine karşı başlatacağız.

Deneme adını ayarlama ve proje klasörü oluşturma

Burada denemeyi adlandırıp klasörünü oluşturacağız.

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 tanıtım deneme kodunu indirin

TensorFlow'un deposunda kapsamlı TensorBoard izlemesi içeren bir MNIST tanıtımı vardır. Azure Machine Learning ile çalışması için bu tanıtım kodunu değiştirmemiz de gerekmez. Aşağıdaki kodda MNIST kodunu indirir ve yeni oluşturulan deneme klasörünüzde kaydederiz.

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)

MNIST kod dosyasının tamamında, mnist_with_summaries.py, vbtf.summary.histogram()tf.summary.FileWriter(). çağıran tf.summary.scalar()satırlar olduğuna dikkat edin. Bu yöntemler denemelerinizin temel ölçümlerini iş geçmişinde gruplandırıp, günlüğe kaydeder ve etiketler. tf.summary.FileWriter(), tensorBoard'un bunlardan görselleştirmeler oluşturmasına olanak tanıyan, günlüğe kaydedilen deneme ölçümlerinizdeki verileri seri hale getirmesi nedeniyle özellikle önemlidir.

Denemeyi yapılandırma

Aşağıda, denememizi yapılandırıp günlükler ve veriler için dizinler ayarlayacağız. Bu günlükler, TensorBoard'un daha sonra eriştiği iş geçmişine yüklenir.

Not

Bu TensorFlow örneği için yerel makinenize TensorFlow yüklemeniz gerekir. Ayrıca, TensorBoard modülüne (TensorFlow'a dahil olan modül) bu not defterinin çekirdeğine erişilebilir olmalıdır çünkü Yerel makine TensorBoard'u çalıştırır.

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)

Denemeniz için küme oluşturma

Bu deneme için bir AmlCompute kümesi oluştururuz, ancak denemeleriniz herhangi bir ortamda oluşturulabilir ve deneme iş geçmişine karşı TensorBoard'u başlatmaya devam edebilirsiniz.

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

Eğitim işini yapılandırma ve gönderme

ScriptRunConfig nesnesi oluşturarak bir eğitim işi yapılandırın.

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'u başlatma

Çalıştırmanız sırasında veya tamamlandıktan sonra TensorBoard'u başlatabilirsiniz. Aşağıda, içinde yüklenen jobdeneme işi geçmişini alan ve ardından yöntemiyle start() TensorBoard'u başlatan bir TensorBoard nesne örneği tboluştururuz.

TensorBoard oluşturucu bir iş dizisi aldığından emin olun ve bunu tek öğeli bir dizi olarak geçirin.

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

Not

Bu örnekte TensorFlow kullanılmış olsa da, TensorBoard PyTorch veya Chainer ile kolayca kullanılabilir. TensorBoard çalıştıran makinede TensorFlow bulunmalıdır, ancak PyTorch veya Chainer hesaplamaları yapan makinede gerekli değildir.

Seçenek 2: TensorBoard'da görüntülemek için geçmişi günlük olarak dışarı aktarma

Aşağıdaki kod örnek bir deneme ayarlar, Azure Machine Learning iş geçmişi API'lerini kullanarak günlüğe kaydetme işlemini başlatır ve deneme iş geçmişini Görselleştirme için TensorBoard tarafından tüketilebilen günlüklere aktarır.

Denemeyi ayarlama

Aşağıdaki kod yeni bir deneme ayarlar ve iş dizinine adını verir 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()

Burada scikit-learn ile birlikte gelen yerleşik küçük bir veri kümesi olan diyabet veri kümesini yükleyip test ve eğitim kümelerine böleceğiz.

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

Deneme ve günlük ölçümlerini çalıştırma

Bu kod için, çalıştırma geçmişinde doğrusal bir regresyon modeli ve günlük anahtarı ölçümleri, alphaalfa katsayısı, ve ortalama kare hatası , mseeğitiriz.

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)

İşleri TensorBoard'a aktarma

SDK'nın export_to_tensorboard() yöntemiyle Azure makine öğrenmesi denememizin iş geçmişini TensorBoard günlüklerine aktarabilir, böylece bunları TensorBoard aracılığıyla görüntüleyebiliriz.

Aşağıdaki kodda klasörü logdir geçerli çalışma dizinimizde oluşturacağız. Bu klasör, deneme işi geçmişimizi ve günlüklerimizi root_run dışarı aktaracağımız ve ardından bu işi tamamlandı olarak işaretlediğimiz yerdir.

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

Not

Ayrıca, çalıştırmanın adını belirterek belirli bir çalıştırmayı TensorBoard'a dışarı aktarabilirsiniz export_to_tensorboard(run_name, logdir)

TensorBoard'u başlatma ve durdurma

Bu denemenin iş geçmişi dışarı aktarıldıktan sonra start() yöntemiyle TensorBoard'u başlatabiliriz.

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

İşiniz bittiğinde TensorBoard nesnesinin stop() yöntemini çağırdığınızdan emin olun. Aksi takdirde, siz not defteri çekirdeğini kapatana kadar TensorBoard çalışmaya devam eder.

tb.stop()

Sonraki adımlar

Bu nasıl yapılır bölümünde iki deneme oluşturdunuz ve olası ayarlama ve yeniden eğitme alanlarını belirlemek için TensorBoard'u iş geçmişlerine karşı başlatmayı öğrendiniz.

  • Modelinizden memnunsanız Model dağıtma makalemize gidin.
  • Hiper parametre ayarlama hakkında daha fazla bilgi edinin.