 Lihat di TensorFlow.org |  Jalankan di Google Colab |  Lihat sumber di GitHub |
Ringkasan
Pembelajaran mesin selalu melibatkan pemahaman metrik utama seperti kerugian dan bagaimana metrik tersebut berubah saat pelatihan berlangsung. Metrik ini dapat membantu Anda memahami jika Anda overfitting , misalnya, atau jika Anda pelatihan tidak perlu berada terlalu lama. Anda mungkin ingin membandingkan metrik ini di berbagai pelatihan yang berjalan untuk membantu men-debug dan meningkatkan model Anda.
TensorBoard ini skalar 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 mempelajari cara menggunakan callback Keras TensorBoard dan API Ringkasan TensorFlow 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 terbaik fit untuk satu set data yang dipasangkan. (Sementara menggunakan jaringan saraf dan gradient descent adalah berlebihan untuk masalah seperti ini , itu tidak membuat untuk contoh yang sangat mudah dimengerti.)
Anda akan menggunakan TensorBoard untuk mengamati bagaimana pelatihan dan kehilangan uji perubahan di zaman. Mudah-mudahan, Anda akan melihat kerugian pelatihan dan pengujian berkurang dari waktu ke waktu dan kemudian tetap stabil.
Pertama, menghasilkan 1000 titik data kasar sepanjang garis y = 0.5x + 2. Pisahkan titik data ini menjadi set pelatihan dan pengujian. 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:]
Melatih model dan mencatat kerugian
Anda sekarang siap untuk mendefinisikan, melatih, dan mengevaluasi model Anda.
Untuk log skalar kerugian seperti yang Anda melatih, Anda akan melakukan hal berikut:
- Buat Keras callback TensorBoard
- Tentukan direktori log
- Lulus callback TensorBoard untuk Keras' Model.fit () .
TensorBoard membaca data log dari hierarki direktori log. Dalam notebook ini, direktori log root adalah logs/scalars , akhiran oleh subdirektori timestamped. Subdirektori stempel waktu memungkinkan Anda untuk dengan mudah mengidentifikasi dan memilih pelatihan yang berjalan saat Anda menggunakan TensorBoard dan melakukan iterasi pada 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(learning_rate=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 root log yang Anda gunakan di atas.
Tunggu beberapa detik hingga UI TensorBoard berputar.
%tensorboard --logdir logs/scalars
Anda mungkin melihat TensorBoard menampilkan pesan "Tidak ada dasbor yang aktif untuk kumpulan data saat ini". Itu karena data logging awal belum disimpan. Saat pelatihan berlangsung, model Keras akan mulai mencatat data. TensorBoard akan menyegarkan dan menampilkan metrik skalar Anda secara berkala. Jika Anda tidak sabar, Anda dapat mengetuk panah Segarkan di kanan atas.
Saat Anda melihat kemajuan pelatihan, perhatikan bagaimana pelatihan dan kehilangan validasi berkurang dengan cepat, dan kemudian tetap stabil. Sebenarnya, Anda bisa saja menghentikan latihan setelah 25 epoch, karena latihan tidak banyak meningkat setelah titik itu.
Arahkan kursor ke grafik untuk melihat titik data tertentu. Anda juga dapat mencoba memperbesar dengan mouse, atau memilih sebagian untuk melihat lebih detail.
Perhatikan pemilih "Runs" di sebelah kiri. Sebuah "run" mewakili satu set log dari putaran pelatihan, dalam hal ini hasil dari Model.fit(). Pengembang biasanya memiliki banyak, banyak proses, saat mereka bereksperimen dan mengembangkan model mereka dari waktu ke waktu.
Gunakan pemilih Runs untuk memilih run tertentu, atau pilih dari hanya pelatihan atau validasi. Membandingkan proses akan membantu Anda mengevaluasi versi kode mana yang memecahkan masalah Anda dengan lebih baik.
Oke, grafik kerugian TensorBoard menunjukkan bahwa kerugian secara konsisten menurun untuk pelatihan dan validasi, lalu stabil. Itu berarti metrik model kemungkinan sangat bagus! Sekarang lihat bagaimana model sebenarnya berperilaku dalam kehidupan nyata.
Mengingat input data (60, 25, 2), garis y = 0.5x + 2 harus 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 skalar khusus
Bagaimana jika Anda ingin log nilai-nilai adat, seperti tingkat belajar yang dinamis ? Untuk melakukannya, Anda perlu menggunakan TensorFlow Summary API.
Latih kembali model regresi dan catat tingkat pembelajaran khusus. Berikut caranya:
- Buat seorang penulis berkas, menggunakan
tf.summary.create_file_writer(). - Tentukan fungsi kecepatan pembelajaran khusus. Ini akan diteruskan ke Keras LearningRateScheduler callback.
- Di dalam fungsi tingkat pembelajaran, penggunaan
tf.summary.scalar()untuk log tingkat pembelajaran kustom. - Teruskan callback LearningRateScheduler ke Model.fit().
Secara umum, untuk log skalar kustom, Anda perlu menggunakan tf.summary.scalar() dengan seorang penulis berkas. 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 "Berjalan" pemilih di sebelah kiri, pemberitahuan bahwa Anda memiliki <timestamp>/metrics run. Memilih proses ini akan menampilkan grafik "kecepatan pembelajaran" yang memungkinkan Anda untuk memverifikasi perkembangan kecepatan pembelajaran selama proses ini.
Anda juga dapat membandingkan pelatihan lari ini dan kurva kehilangan validasi dengan lari Anda sebelumnya. Anda mungkin juga memperhatikan bahwa jadwal kecepatan pembelajaran mengembalikan nilai diskrit, tergantung pada zaman, tetapi plot kecepatan pembelajaran mungkin tampak mulus. TensorBoard memiliki parameter pemulusan yang mungkin perlu Anda turunkan ke nol untuk melihat nilai yang tidak dihaluskan.
Bagaimana model ini lakukan?
print(model.predict([60, 25, 2]))
# True values to compare predictions against:
# [[32.0]
# [14.5]
# [ 3.0]]
[[32.234013 ] [14.5973015] [ 3.0074618]]