Skalary TensorBoard: Rejestrowanie metryk treningowych w Keras

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub

Przegląd

Uczenie maszynowe niezmiennie wiąże się ze zrozumieniem kluczowych wskaźników, takich jak przegrana, oraz tego, jak zmieniają się one wraz z postępem szkolenia. Te dane mogą pomóc zrozumieć, jeśli przeuczenia , na przykład, albo jeśli jesteś niepotrzebnie szkolenie zbyt długo. Możesz chcieć porównać te metryki w różnych cyklach treningowych, aby pomóc w debugowaniu i ulepszaniu modelu.

TensorBoard za Skalary Dashboard umożliwia wizualizację tych metryk za pomocą prostego interfejsu API z niewielkim wysiłkiem. Ten samouczek przedstawia bardzo podstawowe przykłady, które pomogą Ci nauczyć się korzystać z tych interfejsów API z TensorBoard podczas tworzenia modelu Keras. Dowiesz się, jak wykorzystać interfejsy API wywołania zwrotnego Keras TensorBoard i TensorFlow Summary do wizualizacji domyślnych i niestandardowych skalarów.

Ustawiać

# 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

Skonfiguruj dane do prostej regresji

Masz teraz zamiar użyć Keras do obliczenia regresji, czyli znaleźć najlepszą linię ataku na połączonemu zbioru danych. (Podczas korzystania z sieci neuronowych i metoda gradientu prostego jest przesadą dla tego rodzaju problemu , to czyni na przykład bardzo łatwe do zrozumienia.)

Masz zamiar użyć TensorBoard obserwować, jak szkolenia i strat próba zmiany całej epok. Miejmy nadzieję, że z biegiem czasu zaobserwujesz spadek strat w treningu i testach, a następnie pozostaniesz na stałym poziomie.

Po pierwsze, generuje 1000 punktów danych w przybliżeniu wzdłuż linii y = 0,5 x + 2. Podziel te punkty danych na zestawy treningowe i testowe. Masz nadzieję, że sieć neuronowa nauczy się tego związku.

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:]

Trenowanie modelu i rejestrowanie strat

Teraz możesz już zdefiniować, przeszkolić i ocenić swój model.

Aby zalogować skalara strat, jak trenować, musisz wykonać następujące czynności:

  1. Tworzenie Keras zwrotnego TensorBoard
  2. Określ katalog dziennika
  3. Przepuścić zwrotnego TensorBoard do Keras' Model.fit () .

TensorBoard odczytuje dane dziennika z hierarchii katalogów dziennika. W tym notebooku, katalog log korzeń jest logs/scalars , sufiksem podkatalogu czas utworzenia. Podkatalog ze znacznikiem czasu umożliwia łatwe identyfikowanie i wybieranie przebiegów treningowych podczas korzystania z TensorBoard i iteracji na modelu.

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

Badanie strat za pomocą TensorBoard

Teraz uruchom TensorBoard, określając katalog główny dziennika, którego użyłeś powyżej.

Poczekaj kilka sekund, aż interfejs użytkownika TensorBoard się rozkręci.

%tensorboard --logdir logs/scalars

Możesz zobaczyć, że TensorBoard wyświetla komunikat „Żadne pulpity nie są aktywne dla bieżącego zestawu danych”. Dzieje się tak, ponieważ początkowe dane logowania nie zostały jeszcze zapisane. W miarę postępu szkolenia model Keras rozpocznie rejestrowanie danych. TensorBoard będzie okresowo odświeżał i wyświetlał metryki skalarne. Jeśli jesteś niecierpliwy, możesz kliknąć strzałkę Odśwież w prawym górnym rogu.

Obserwując postępy w treningu, zwróć uwagę, jak utrata treningu i walidacji gwałtownie maleje, a następnie pozostaje stabilna. W rzeczywistości mogłeś przestać trenować po 25 epokach, ponieważ trening nie poprawił się zbytnio po tym punkcie.

Najedź kursorem na wykres, aby zobaczyć określone punkty danych. Możesz także spróbować powiększyć za pomocą myszy lub wybrać część z nich, aby wyświetlić więcej szczegółów.

Zwróć uwagę na selektor „Runs” po lewej stronie. „Run” reprezentuje zestaw dzienników z rundy szkolenia, w tym przypadku wynik Model.fit(). Deweloperzy zazwyczaj mają wiele, wiele uruchomień, ponieważ z czasem eksperymentują i rozwijają swój model.

Użyj selektora biegów, aby wybrać konkretne biegi lub wybierz tylko trening lub walidację. Porównanie przebiegów pomoże Ci ocenić, która wersja Twojego kodu lepiej rozwiązuje Twój problem.

Ok, wykres strat TensorBoard pokazuje, że strata konsekwentnie malała zarówno w przypadku szkolenia, jak i walidacji, a następnie ustabilizowała się. Oznacza to, że metryki modelu są prawdopodobnie bardzo dobre! Teraz zobacz, jak model zachowuje się w rzeczywistości.

Biorąc pod uwagę dane wejściowe (60, 25, 2), linia y = 0,5 x + 2 powinien dawać (32, 14.5, 3). Czy model się zgadza?

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

Nie jest zły!

Rejestrowanie niestandardowych skalarów

Co zrobić, jeśli chcesz się zalogować wartości niestandardowe, takie jak tempo uczenia dynamicznego ? Aby to zrobić, musisz skorzystać z API TensorFlow Summary.

Ponownie naucz model regresji i zarejestruj niestandardową szybkość uczenia się. Oto jak:

  1. Tworzenie pisarza pliku, używając tf.summary.create_file_writer() .
  2. Zdefiniuj niestandardową funkcję szybkości uczenia się. Cel ten zostanie przekazany do Keras LearningRateScheduler zwrotnego.
  3. Wewnątrz funkcji szybkości uczenia się, korzystanie tf.summary.scalar() , aby zalogować się niestandardową szybkość uczenia się.
  4. Przekaż wywołanie zwrotne LearningRateScheduler do Model.fit().

W ogóle, do logowania niestandardowego skalarne, trzeba użyć tf.summary.scalar() z pisarzem plików. Pisarz plik jest odpowiedzialny za zapisywanie danych w tym okresie do określonego katalogu i jest niejawnie stosowane podczas korzystania z 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],
)

Przyjrzyjmy się ponownie TensorBoard.

%tensorboard --logdir logs/scalars

Korzystanie z selektora „biegnie” po lewej stronie, zawiadomienia, że masz <timestamp>/metrics bieg. Wybranie tego biegu powoduje wyświetlenie wykresu „szybkości uczenia się”, który umożliwia weryfikację postępu tempa uczenia się podczas tego biegu.

Możesz także porównać krzywe utraty treningu i walidacji z tego biegu z wcześniejszymi biegami. Można również zauważyć, że harmonogram tempa uczenia się zwracał wartości dyskretne, w zależności od epoki, ale wykres tempa uczenia się może wydawać się płynny. TensorBoard ma parametr wygładzania, który może być potrzebny do zmniejszenia do zera, aby zobaczyć niewygładzone wartości.

Jak działa ten model?

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