Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

Mulai dengan TensorBoard

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

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

Mulai cepat ini akan menunjukkan cara memulai dengan TensorBoard dengan cepat. Panduan yang tersisa di situs web ini memberikan rincian lebih lanjut tentang kapabilitas spesifik, banyak di antaranya tidak termasuk 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 sederhana 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 Keras's Model.fit () , menambahkan tf.keras.callbacks.TensorBoard callback memastikan bahwa log dibuat dan disimpan. Selain itu, aktifkan perhitungan histogram setiap zaman dengan histogram_freq=1 (ini dinonaktifkan secara default)

Tempatkan log dalam subdirektori timestamped untuk memudahkan pemilihan berbagai pelatihan yang berbeda.

 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 buku catatan, gunakan sihir garis %tensorboard . Di baris perintah, jalankan perintah yang sama tanpa "%".

 %tensorboard --logdir logs/fit
 

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

  • Dasbor Scalars menunjukkan bagaimana kehilangan dan metrik berubah setiap zaman. Anda dapat menggunakannya untuk melacak kecepatan pelatihan, tingkat 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.
  • Dashboard Distribusi dan Histogram menunjukkan distribusi Tensor dari waktu ke waktu. Ini berguna untuk memvisualisasikan bobot dan bias dan memverifikasi bahwa mereka berubah dengan cara yang diharapkan.

Plugin TensorBoard tambahan secara otomatis diaktifkan ketika Anda mencatat tipe data lainnya. Misalnya, panggilan balik Keras TensorBoard memungkinkan Anda mencatat gambar dan embeddings juga. Anda dapat melihat plugin apa yang tersedia di TensorBoard dengan mengeklik dropdown "tidak aktif" ke kanan atas.

Menggunakan TensorBoard dengan metode lain

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

Gunakan dataset yang sama seperti di atas, tetapi konversikan ke tf.data.Dataset untuk memanfaatkan 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 tutorial mulai cepat lanjutan , tetapi menunjukkan cara login metrik ke TensorBoard. Pilih kerugian dan pengoptimal:

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

Buat metrik stateful yang dapat digunakan untuk mengakumulasi nilai selama pelatihan dan login kapan saja:

 # 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 tes:

 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 mencatat metrik (kehilangan dan ketepatan) 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 logging tipe data lainnya.

 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 bisa memulai TensorBoard untuk memantau pelatihan saat berlangsung.

 %tensorboard --logdir logs/gradient_tape
 

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