Memulai TensorBoard

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub Unduh buku catatan

Dalam pembelajaran mesin, untuk meningkatkan sesuatu, Anda sering kali harus dapat mengukurnya. TensorBoard adalah alat untuk menyediakan pengukuran dan visualisasi yang diperlukan selama alur kerja machine learning. Ini memungkinkan pelacakan metrik eksperimen seperti kehilangan dan akurasi, memvisualisasikan grafik model, memproyeksikan embeddings ke ruang dimensi yang lebih rendah, dan banyak lagi.

Panduan memulai ini akan menunjukkan cara memulai TensorBoard dengan cepat. Panduan lainnya di situs web ini memberikan rincian lebih lanjut tentang kemampuan khusus, banyak di antaranya tidak disertakan di sini.

# Load the TensorBoard notebook extension
%load_ext tensorboard
import tensorflow as tf
import datetime
# Clear any logs from previous runs
rm -rf ./logs/

Menggunakan MNIST dataset sebagai contoh, menormalkan data dan menulis fungsi yang menciptakan model Keras sederhana untuk mengklasifikasikan gambar ke 10 kelas.

mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

Menggunakan TensorBoard dengan Keras Model.fit()

Ketika berlatih dengan Keras ini Model.fit () , menambahkan tf.keras.callbacks.TensorBoard callback memastikan bahwa kayu yang dibuat dan disimpan. Selain itu, memungkinkan histogram perhitungan setiap zaman dengan histogram_freq=1 (ini tidak aktif secara default)

Tempatkan log di subdirektori yang diberi cap waktu untuk memudahkan pemilihan berbagai pelatihan yang berjalan.

model = create_model()
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

model.fit(x=x_train, 
          y=y_train, 
          epochs=5, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])
Train on 60000 samples, validate on 10000 samples
Epoch 1/5
60000/60000 [==============================] - 15s 246us/sample - loss: 0.2217 - accuracy: 0.9343 - val_loss: 0.1019 - val_accuracy: 0.9685
Epoch 2/5
60000/60000 [==============================] - 14s 229us/sample - loss: 0.0975 - accuracy: 0.9698 - val_loss: 0.0787 - val_accuracy: 0.9758
Epoch 3/5
60000/60000 [==============================] - 14s 231us/sample - loss: 0.0718 - accuracy: 0.9771 - val_loss: 0.0698 - val_accuracy: 0.9781
Epoch 4/5
60000/60000 [==============================] - 14s 227us/sample - loss: 0.0540 - accuracy: 0.9820 - val_loss: 0.0685 - val_accuracy: 0.9795
Epoch 5/5
60000/60000 [==============================] - 14s 228us/sample - loss: 0.0433 - accuracy: 0.9862 - val_loss: 0.0623 - val_accuracy: 0.9823
<tensorflow.python.keras.callbacks.History at 0x7fc8a5ee02e8>

Mulai TensorBoard melalui baris perintah atau dalam pengalaman notebook. Kedua antarmuka umumnya sama. Di notebook, gunakan %tensorboard magic line. Pada baris perintah, jalankan perintah yang sama tanpa "%".

%tensorboard --logdir logs/fit

Ikhtisar singkat tentang dasbor yang ditampilkan (tab di bilah navigasi atas):

  • The skalar dashboard menunjukkan bagaimana hilangnya dan metrik berubah dengan setiap zaman. Anda juga dapat menggunakannya untuk melacak kecepatan pelatihan, kecepatan pembelajaran, dan nilai skalar lainnya.
  • The Grafik dashboard membantu Anda memvisualisasikan model Anda. Dalam hal ini, grafik lapisan Keras ditampilkan yang dapat membantu Anda memastikannya dibangun dengan benar.
  • The Distribusi dan Histogram dashboard menunjukkan distribusi dari Tensor dari waktu ke waktu. Ini dapat berguna untuk memvisualisasikan bobot dan bias dan memverifikasi bahwa mereka berubah dengan cara yang diharapkan.

Plugin TensorBoard tambahan diaktifkan secara otomatis saat Anda mencatat jenis data lain. Misalnya, callback Keras TensorBoard memungkinkan Anda mencatat gambar dan embeddings juga. Anda dapat melihat plugin lain yang tersedia di TensorBoard dengan mengklik dropdown "tidak aktif" di kanan atas.

Menggunakan TensorBoard dengan metode lain

Ketika pelatihan dengan metode seperti tf.GradientTape() , gunakan tf.summary untuk log informasi yang diperlukan.

Gunakan dataset yang sama seperti di atas, tetapi mengubahnya menjadi tf.data.Dataset untuk mengambil keuntungan dari kemampuan batching:

train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))

train_dataset = train_dataset.shuffle(60000).batch(64)
test_dataset = test_dataset.batch(64)

Kode pelatihan mengikuti canggih quickstart tutorial, tapi menunjukkan bagaimana log metrik untuk TensorBoard. Pilih kerugian dan pengoptimal:

loss_object = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = tf.keras.optimizers.Adam()

Buat metrik stateful yang dapat digunakan untuk mengumpulkan nilai selama pelatihan dan dicatat di titik mana pun:

# Define our metrics
train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32)
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('train_accuracy')
test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32)
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy('test_accuracy')

Tentukan fungsi pelatihan dan pengujian:

def train_step(model, optimizer, x_train, y_train):
  with tf.GradientTape() as tape:
    predictions = model(x_train, training=True)
    loss = loss_object(y_train, predictions)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  train_loss(loss)
  train_accuracy(y_train, predictions)

def test_step(model, x_test, y_test):
  predictions = model(x_test)
  loss = loss_object(y_test, predictions)

  test_loss(loss)
  test_accuracy(y_test, predictions)

Siapkan penulis ringkasan untuk menulis ringkasan ke disk di direktori log yang berbeda:

current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
train_log_dir = 'logs/gradient_tape/' + current_time + '/train'
test_log_dir = 'logs/gradient_tape/' + current_time + '/test'
train_summary_writer = tf.summary.create_file_writer(train_log_dir)
test_summary_writer = tf.summary.create_file_writer(test_log_dir)

Mulai pelatihan. Gunakan tf.summary.scalar() untuk log metrik (rugi dan akurasi) selama pelatihan / pengujian dalam lingkup penulis ringkasan untuk menulis ringkasan ke disk. Anda memiliki kendali atas metrik mana yang harus dicatat dan seberapa sering melakukannya. Lainnya tf.summary fungsi mengaktifkan logging jenis data.

model = create_model() # reset our model

EPOCHS = 5

for epoch in range(EPOCHS):
  for (x_train, y_train) in train_dataset:
    train_step(model, optimizer, x_train, y_train)
  with train_summary_writer.as_default():
    tf.summary.scalar('loss', train_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', train_accuracy.result(), step=epoch)

  for (x_test, y_test) in test_dataset:
    test_step(model, x_test, y_test)
  with test_summary_writer.as_default():
    tf.summary.scalar('loss', test_loss.result(), step=epoch)
    tf.summary.scalar('accuracy', test_accuracy.result(), step=epoch)

  template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
  print (template.format(epoch+1,
                         train_loss.result(), 
                         train_accuracy.result()*100,
                         test_loss.result(), 
                         test_accuracy.result()*100))

  # Reset metrics every epoch
  train_loss.reset_states()
  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()
Epoch 1, Loss: 0.24321186542510986, Accuracy: 92.84333801269531, Test Loss: 0.13006582856178284, Test Accuracy: 95.9000015258789
Epoch 2, Loss: 0.10446818172931671, Accuracy: 96.84833526611328, Test Loss: 0.08867532759904861, Test Accuracy: 97.1199951171875
Epoch 3, Loss: 0.07096975296735764, Accuracy: 97.80166625976562, Test Loss: 0.07875105738639832, Test Accuracy: 97.48999786376953
Epoch 4, Loss: 0.05380449816584587, Accuracy: 98.34166717529297, Test Loss: 0.07712937891483307, Test Accuracy: 97.56999969482422
Epoch 5, Loss: 0.041443776339292526, Accuracy: 98.71833038330078, Test Loss: 0.07514958828687668, Test Accuracy: 97.5

Buka TensorBoard lagi, kali ini arahkan ke direktori log baru. Kami juga dapat memulai TensorBoard untuk memantau pelatihan saat pelatihan berlangsung.

%tensorboard --logdir logs/gradient_tape

Itu dia! Sekarang Anda telah melihat bagaimana menggunakan TensorBoard baik melalui panggilan balik Keras dan melalui tf.summary untuk skenario kustom lebih.

TensorBoard.dev: Host dan bagikan hasil eksperimen ML Anda

TensorBoard.dev adalah layanan umum gratis yang memungkinkan Anda untuk meng-upload log TensorBoard Anda dan mendapatkan permalink yang bisa dibagi dengan semua orang dalam makalah akademis, posting blog, media sosial, dll Hal ini dapat memungkinkan reproduktifitas yang lebih baik dan kolaborasi.

Untuk menggunakan TensorBoard.dev, jalankan perintah berikut:

!tensorboard dev upload \
  --logdir logs/fit \
  --name "(optional) My latest experiment" \
  --description "(optional) Simple comparison of several hyperparameters" \
  --one_shot

Perhatikan bahwa doa ini menggunakan seru awalan ( ! ) Untuk memohon shell daripada persen awalan ( % ) untuk memohon sihir colab. Saat menjalankan perintah ini dari baris perintah, tidak perlu ada awalan.

Lihat contoh di sini .

Untuk rincian lebih lanjut tentang cara menggunakan TensorBoard.dev, lihat https://tensorboard.dev/#get-started