Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Skalary TensorBoard: rejestrowanie wskaźników treningowych w Keras

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

Przegląd

Uczenie maszynowe niezmiennie obejmuje zrozumienie kluczowych wskaźników, takich jak straty i ich zmian w miarę postępu szkolenia. Te wskaźniki mogą pomóc Ci zrozumieć, na przykład, czy nadmiernie się dopasowujesz lub jeśli niepotrzebnie trenujesz zbyt długo. Możesz chcieć porównać te metryki w różnych przebiegach treningowych, aby pomóc w debugowaniu i ulepszeniu modelu.

TensorBoard za Skalary Dashboard umożliwia wizualizację tych metryk za pomocą prostego interfejsu API z niewielkim wysiłkiem. W tym samouczku przedstawiono bardzo podstawowe przykłady, które pomogą Ci nauczyć się korzystania z tych interfejsów API z TensorBoard podczas tworzenia modelu Keras. Dowiesz się, jak używać wywołań zwrotnych Keras TensorBoard i interfejsów API podsumowania TensorFlow 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

Teraz użyjesz Keras do obliczenia regresji, tj. Do znalezienia najlepszej linii dopasowania dla sparowanego zestawu danych. (Chociaż korzystanie z sieci neuronowych i zejścia gradientowego jest przesadą w przypadku tego rodzaju problemów , jest to bardzo łatwy do zrozumienia przykład).

Masz zamiar użyć TensorBoard obserwować, jak szkolenia i strat próba zmiany całej epok. Miejmy nadzieję, że z biegiem czasu zmniejszy się strata treningu i testów, a następnie pozostanie stabilna.

Najpierw wygeneruj 1000 punktów danych w przybliżeniu wzdłuż linii y = 0,5x + 2 . Podziel te punkty danych na zbiory uczące 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:]
 

Trening modelu i utrata logowania

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

Aby zarejestrować skalar straty podczas treningu, wykonaj następujące czynności:

  1. Utwórz wywołanie zwrotne Keras TensorBoard
  2. Określ katalog dziennika
  3. Przekaż wywołanie zwrotne TensorBoard do Model.fit () Keras.

TensorBoard odczytuje dane dziennika z hierarchii katalogu dzienników. W tym notatniku głównym katalogiem dziennika jest logs/scalars , z sufiksem podkatalogu ze znacznikiem czasu. Podkatalog z sygnaturą czasową umożliwia łatwe identyfikowanie i wybieranie przebiegów treningowych podczas korzystania z TensorBoard i iteracji w 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(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

Badanie strat za pomocą TensorBoard

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

Poczekaj kilka sekund, aż interfejs TensorBoard się uruchomi.

 %tensorboard --logdir logs/scalars
 

Możesz zobaczyć, że TensorBoard wyświetla komunikat „Brak aktywnych pulpitów nawigacyjnych dla bieżącego zestawu danych”. Dzieje się tak, ponieważ początkowe dane logowania nie zostały jeszcze zapisane. W miarę postępów szkolenia model Keras rozpocznie rejestrowanie danych. TensorBoard będzie okresowo odświeżać i wyświetlać metryki skalarne. Jeśli nie możesz się doczekać, możesz dotknąć strzałki Odśwież w prawym górnym rogu.

Obserwując postęp treningu, zwróć uwagę, jak szybko zmniejszają się straty podczas treningu i walidacji, a następnie pozostają stabilne. W rzeczywistości można było przestać trenować po 25 epokach, ponieważ po tym czasie trening niewiele się poprawił.

Najedź kursorem na wykres, aby zobaczyć konkretne 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. „Uruchomienie” reprezentuje zbiór dzienników z rundy treningu, w tym przypadku wynik Model.fit (). Deweloperzy zazwyczaj mają wiele, wiele uruchomień, ponieważ eksperymentują i rozwijają swój model w czasie.

Użyj selektora Przebiegi, aby wybrać określone przebiegi lub wybierz tylko trening lub walidację. Porównanie przebiegów pomoże Ci ocenić, która wersja kodu lepiej rozwiązuje Twój problem.

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

Biorąc pod uwagę dane wejściowe (60, 25, 2), wiersz y = 0,5x + 2 powinien dać (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

A jeśli chcesz rejestrować wartości niestandardowe, takie jak dynamiczna szybkość uczenia się ? Aby to zrobić, musisz użyć interfejsu API podsumowania TensorFlow.

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

  1. Utwórz program zapisujący pliki, używając tf.summary.create_file_writer() .
  2. Zdefiniuj niestandardową funkcję szybkości uczenia się. Zostanie to przekazane do wywołania zwrotnego Keras LearningRateScheduler .
  3. W funkcji współczynnika uczenia użyj tf.summary.scalar() aby zarejestrować niestandardową szybkość uczenia się.
  4. Przekaż wywołanie zwrotne LearningRateScheduler do Model.fit ().

Ogólnie, aby zarejestrować niestandardowy skalar, musisz użyć tf.summary.scalar() z programem zapisującym pliki. Program zapisujący plik jest odpowiedzialny za zapisywanie danych dla tego uruchomienia w określonym katalogu i jest używany niejawnie podczas korzystania z funkcji 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],
)
 

Spójrzmy ponownie na TensorBoard.

 %tensorboard --logdir logs/scalars
 

Używając selektora „Runs” po lewej stronie, zwróć uwagę, że masz przebieg <timestamp>/metrics . Wybranie tego biegu powoduje wyświetlenie wykresu „szybkości uczenia się”, który umożliwia weryfikację postępów szybkości uczenia się podczas tego biegu.

Możesz także porównać krzywe straty treningu i walidacji tego biegu z wcześniejszymi biegami.

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