Halaman ini diterjemahkan oleh Cloud Translation API.
Switch to English

TensorBoard Scalars: Metrik pelatihan logging di Keras

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

Gambaran

Pembelajaran mesin selalu melibatkan pemahaman metrik kunci seperti kehilangan dan bagaimana mereka berubah saat pelatihan berlangsung. Metrik ini dapat membantu Anda memahami jika Anda overfitting , misalnya, atau jika Anda terlalu lama berlatih terlalu lama. Anda mungkin ingin membandingkan metrik ini di berbagai pelatihan yang berbeda untuk membantu men-debug dan meningkatkan model Anda.

Dashboard TensorBoard's Dashboard memungkinkan Anda untuk memvisualisasikan metrik ini menggunakan API sederhana dengan sedikit usaha. Tutorial ini menyajikan contoh yang sangat mendasar untuk membantu Anda mempelajari cara menggunakan API ini dengan TensorBoard saat mengembangkan model Keras Anda. Anda akan belajar cara menggunakan panggilan balik Keras TensorBoard dan TensorFlow Summary untuk memvisualisasikan skalar default dan kustom.

Mempersiapkan

 # Load the TensorBoard notebook extension.
%load_ext tensorboard
 
 from datetime import datetime
from packaging import version

import tensorflow as tf
from tensorflow import keras

import numpy as np

print("TensorFlow version: ", tf.__version__)
assert version.parse(tf.__version__).release[0] >= 2, \
    "This notebook requires TensorFlow 2.0 or above."
 
TensorFlow version:  2.2

Siapkan data untuk regresi sederhana

Anda sekarang akan menggunakan Keras untuk menghitung regresi, yaitu, menemukan garis paling pas untuk kumpulan data yang dipasangkan. (Meskipun menggunakan jaringan saraf dan penurunan gradien terlalu banyak untuk masalah seperti ini , itu membuat contoh yang sangat mudah dimengerti.)

Anda akan menggunakan TensorBoard untuk mengamati bagaimana pelatihan dan pengujian perubahan kerugian di seluruh zaman. Semoga, Anda akan melihat pelatihan dan kehilangan tes menurun dari waktu ke waktu dan kemudian tetap stabil.

Pertama, hasilkan 1000 titik data secara kasar di sepanjang garis y = 0,5x + 2 . Bagi poin-poin data ini menjadi pelatihan dan set tes. Harapan Anda adalah bahwa jaringan saraf mempelajari hubungan ini.

 data_size = 1000
# 80% of the data is for training.
train_pct = 0.8

train_size = int(data_size * train_pct)

# Create some input data between -1 and 1 and randomize it.
x = np.linspace(-1, 1, data_size)
np.random.shuffle(x)

# Generate the output data.
# y = 0.5x + 2 + noise
y = 0.5 * x + 2 + np.random.normal(0, 0.05, (data_size, ))

# Split into test and train pairs.
x_train, y_train = x[:train_size], y[:train_size]
x_test, y_test = x[train_size:], y[train_size:]
 

Pelatihan model dan kehilangan logging

Anda sekarang siap untuk mendefinisikan, melatih dan mengevaluasi model Anda.

Untuk mencatat skalar loss saat Anda berlatih, Anda akan melakukan hal berikut:

  1. Buat panggilan balik Keras TensorBoard
  2. Tentukan direktori log
  3. Lewati panggilan balik TensorBoard ke Keras ' Model.fit () .

TensorBoard membaca data log dari hierarki direktori log. Di buku catatan ini, direktori log root adalah logs/scalars , yang diakhiri dengan subdirektori timestamped. Subdirektori timestamped memungkinkan Anda untuk dengan mudah mengidentifikasi dan memilih pelatihan berjalan saat Anda menggunakan TensorBoard dan beralih ke model Anda.

 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(lr=0.2),
)

print("Training ... With default parameters, this takes less than 10 seconds.")
training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback],
)

print("Average test loss: ", np.average(training_history.history['loss']))
 
Training ... With default parameters, this takes less than 10 seconds.
Average test loss:  0.05271831926424056

Memeriksa kerugian menggunakan TensorBoard

Sekarang, mulai TensorBoard, tentukan direktori log root yang Anda gunakan di atas.

Tunggu beberapa detik hingga TensorBoard UI berputar.

 %tensorboard --logdir logs/scalars
 

Anda mungkin melihat TensorBoard menampilkan pesan "Tidak ada dasbor aktif untuk kumpulan data saat ini". Itu karena data pendataan awal belum disimpan. Saat pelatihan berlangsung, model Keras akan mulai mencatat data. TensorBoard secara berkala akan menyegarkan dan menampilkan metrik skalar Anda. Jika Anda tidak sabar, Anda dapat mengetuk panah Refresh di kanan atas.

Saat Anda menyaksikan kemajuan pelatihan, perhatikan bagaimana pelatihan dan kehilangan validasi menurun dengan cepat, dan kemudian tetap stabil. Bahkan, Anda bisa menghentikan pelatihan setelah 25 zaman, karena pelatihan tidak banyak membaik setelah titik itu.

Arahkan kursor ke grafik untuk melihat titik data tertentu. Anda juga dapat mencoba memperbesar dengan mouse Anda, atau memilih bagian dari mereka untuk melihat lebih detail.

Perhatikan pemilih "Runs" di sebelah kiri. "Lari" mewakili serangkaian log dari putaran pelatihan, dalam hal ini hasil Model.fit (). Pengembang biasanya memiliki banyak, banyak berjalan, saat mereka bereksperimen dan mengembangkan model mereka dari waktu ke waktu.

Gunakan pemilih Lari untuk memilih lari tertentu, atau pilih dari hanya pelatihan atau validasi. Membandingkan proses akan membantu Anda mengevaluasi versi kode Anda yang memecahkan masalah Anda dengan lebih baik.

Ok, grafik kehilangan TensorBoard menunjukkan bahwa kehilangan secara konsisten menurun untuk pelatihan dan validasi dan kemudian stabil. Itu berarti bahwa metrik model kemungkinan sangat bagus! Sekarang lihat bagaimana model sebenarnya berperilaku dalam kehidupan nyata.

Mengingat data input (60, 25, 2), garis y = 0,5x + 2 akan menghasilkan (32, 14,5, 3). Apakah modelnya setuju?

 print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
 
[[32.234306 ]
 [14.5974245]
 [ 3.0074697]]

Tidak buruk!

Mencatat skal khusus

Bagaimana jika Anda ingin mencatat nilai khusus, seperti tingkat pembelajaran dinamis ? Untuk melakukan itu, Anda perlu menggunakan TensorFlow Summary API.

Latih kembali model regresi dan catat tingkat pembelajaran khusus. Begini caranya:

  1. Buat penulis file, menggunakan tf.summary.create_file_writer() .
  2. Tentukan fungsi laju pembelajaran khusus. Ini akan diteruskan ke panggilan balik Keras LearningRateScheduler .
  3. Di dalam fungsi laju pembelajaran, gunakan tf.summary.scalar() untuk mencatat tingkat pembelajaran khusus.
  4. Lewati panggilan balik LearningRateScheduler ke Model.fit ().

Secara umum, untuk mencatat skalar khusus, Anda harus menggunakan tf.summary.scalar() dengan penulis file. Penulis file bertanggung jawab untuk menulis data untuk menjalankan ini ke direktori yang ditentukan dan secara implisit digunakan ketika Anda menggunakan tf.summary.scalar() .

 logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
file_writer = tf.summary.create_file_writer(logdir + "/metrics")
file_writer.set_as_default()

def lr_schedule(epoch):
  """
  Returns a custom learning rate that decreases as epochs progress.
  """
  learning_rate = 0.2
  if epoch > 10:
    learning_rate = 0.02
  if epoch > 20:
    learning_rate = 0.01
  if epoch > 50:
    learning_rate = 0.005

  tf.summary.scalar('learning rate', data=learning_rate, step=epoch)
  return learning_rate

lr_callback = keras.callbacks.LearningRateScheduler(lr_schedule)
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)

model = keras.models.Sequential([
    keras.layers.Dense(16, input_dim=1),
    keras.layers.Dense(1),
])

model.compile(
    loss='mse', # keras.losses.mean_squared_error
    optimizer=keras.optimizers.SGD(),
)

training_history = model.fit(
    x_train, # input
    y_train, # output
    batch_size=train_size,
    verbose=0, # Suppress chatty output; use Tensorboard instead
    epochs=100,
    validation_data=(x_test, y_test),
    callbacks=[tensorboard_callback, lr_callback],
)
 

Mari kita lihat TensorBoard lagi.

 %tensorboard --logdir logs/scalars
 

Menggunakan pemilih "Runs" di sebelah kiri, perhatikan bahwa Anda menjalankan <timestamp>/metrics . Memilih proses ini menampilkan grafik "tingkat pembelajaran" yang memungkinkan Anda untuk memverifikasi perkembangan tingkat pembelajaran selama proses ini.

Anda juga dapat membandingkan latihan lari ini dan kurva kehilangan validasi dengan lari sebelumnya.

Bagaimana model ini?

 print(model.predict([60, 25, 2]))
# True values to compare predictions against: 
# [[32.0]
#  [14.5]
#  [ 3.0]]
 
[[32.234013 ]
 [14.5973015]
 [ 3.0074618]]