Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Mulailah dengan TensorBoard

Lihat di TensorFlow.org Jalankan di Google Colab Lihat sumber di GitHub

Dalam pembelajaran mesin, untuk meningkatkan sesuatu, Anda sering kali harus dapat mengukurnya. TensorBoard adalah fitur untuk menyediakan pengukuran dan visualisasi yang diperlukan selama alur kerja machine learning. Ini memungkinkan pelacakan metrik eksperimen seperti kerugian 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 tertentu, 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 dataset MNIST sebagai contoh, menormalkan data dan menulis fungsi yang membuat model Keras untuk mengklasifikasikan gambar menjadi 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 ()

Saat berlatih dengan Model.fit () Keras, menambahkan callback tf.keras.callbacks.TensorBoard memastikan bahwa log dibuat dan disimpan. Selain itu, aktifkan komputasi histogram setiap epoch dengan histogram_freq=1 (ini dinonaktifkan secara default)

Tempatkan log di subdirektori timestamped untuk memudahkan pemilihan berbagai pelatihan yang dijalankan.

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 command line atau dalam pengalaman notebook. Kedua antarmuka tersebut umumnya sama. Di buku catatan, gunakan sihir garis %tensorboard . Pada baris perintah, jalankan perintah yang sama tanpa "%".

%tensorboard --logdir logs/fit

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

  • Dasbor Skalars menunjukkan bagaimana kerugian dan metrik berubah di setiap periode. Anda juga dapat menggunakannya untuk melacak kecepatan pelatihan, kecepatan pembelajaran, dan nilai skalar lainnya.
  • Dasbor Grafik membantu Anda memvisualisasikan model Anda. Dalam kasus ini, grafik Keras lapisan ditampilkan yang dapat membantu Anda memastikan itu dibangun dengan benar.
  • Dasbor Distribusi dan Histogram menampilkan distribusi Tensor dari waktu ke waktu. Ini dapat berguna untuk memvisualisasikan bobot dan bias dan memverifikasi bahwa keduanya berubah dengan cara yang diharapkan.

Plugin TensorBoard tambahan secara otomatis diaktifkan saat Anda memasukkan jenis data lain. Misalnya, callback Keras TensorBoard memungkinkan Anda membuat log gambar dan embeddings juga. Anda dapat melihat plugin lain apa yang tersedia di TensorBoard dengan mengklik drop-down "tidak aktif" di kanan atas.

Menggunakan TensorBoard dengan metode lain

Saat melatih dengan metode sepertitf.GradientTape() , gunakan tf.summary untuk mencatat informasi yang diperlukan.

Gunakantf.data.Dataset data yang sama seperti di atas, tetapi konversikan ketf.data.Dataset untuk memanfaatkan kapabilitas 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 tutorial memulai cepat lanjutan , tetapi menunjukkan cara mencatat log metrik ke TensorBoard. Pilih kerugian dan pengoptimal:

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

Buat metrik berstatus yang dapat digunakan untuk mengakumulasi nilai selama pelatihan dan dicatat pada 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)

Mulailah berlatih. Gunakan tf.summary.scalar() untuk mencatat metrik (kerugian dan akurasi) selama pelatihan / pengujian dalam lingkup penulis ringkasan untuk menulis ringkasan ke disk. Anda memiliki kendali atas metrik mana yang akan dicatat dan seberapa sering melakukannya. Fungsi tf.summary lainnya memungkinkan pencatatan tipe data lain.

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 sedang berlangsung.

%tensorboard --logdir logs/gradient_tape

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

TensorBoard.dev: Host dan bagikan hasil eksperimen ML Anda

TensorBoard.dev adalah layanan publik gratis yang memungkinkan Anda mengunggah log TensorBoard dan mendapatkan tautan permanen yang dapat dibagikan dengan semua orang di makalah akademis, entri blog, media sosial, dll. Ini dapat memungkinkan reproduktifitas dan kolaborasi yang lebih baik.

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 pemanggilan ini menggunakan awalan tanda seru ( ! ) Untuk memanggil shell daripada awalan persen ( % ) untuk memanggil sihir colab. Saat menjalankan perintah ini dari baris perintah, tidak perlu prefiks mana pun.

Lihat contohnya di sini .

Untuk mengetahui detail selengkapnya tentang cara menggunakan TensorBoard.dev, lihat https://tensorboard.dev/#get-started