Cette page a été traduite par l'API Cloud Translation.
Switch to English

TensorBoard Scalars: journalisation des métriques d'entraînement dans Keras

Voir sur TensorFlow.org Exécuter dans Google Colab Afficher la source sur GitHub

Aperçu

L'apprentissage automatique implique invariablement la compréhension de paramètres clés tels que la perte et la manière dont ils changent au fur et à mesure que la formation progresse. Ces métriques peuvent vous aider à comprendre si vous êtes en surapprentissage , par exemple, ou si vous vous entraînez inutilement pendant trop longtemps. Vous souhaiterez peut-être comparer ces métriques sur différentes exécutions d'entraînement pour vous aider à déboguer et à améliorer votre modèle.

Le tableau de bord Scalars de TensorBoard vous permet de visualiser ces métriques à l'aide d'une API simple avec très peu d'effort. Ce didacticiel présente des exemples très basiques pour vous aider à apprendre à utiliser ces API avec TensorBoard lors du développement de votre modèle Keras. Vous apprendrez à utiliser les API de rappel Keras TensorBoard et TensorFlow Summary pour visualiser les scalaires par défaut et personnalisés.

Installer

 # 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

Configurer des données pour une régression simple

Vous allez maintenant utiliser Keras pour calculer une régression, c'est-à-dire trouver la meilleure ligne d'ajustement pour un ensemble de données appariées. (Bien que l'utilisation de réseaux de neurones et de descente de gradient soit excessive pour ce type de problème , cela en fait un exemple très facile à comprendre.)

Vous allez utiliser TensorBoard pour observer comment la formation et les tests de perte changent à travers les époques. J'espère que vous verrez la perte d'entraînement et de test diminuer avec le temps, puis rester stable.

Tout d'abord, générez 1000 points de données à peu près le long de la ligne y = 0,5x + 2 . Divisez ces points de données en ensembles de formation et de test. Votre espoir est que le réseau neuronal apprenne cette relation.

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

Formation du modèle et enregistrement des pertes

Vous êtes maintenant prêt à définir, former et évaluer votre modèle.

Pour consigner le scalaire de perte pendant que vous vous entraînez, procédez comme suit:

  1. Créer le rappel Keras TensorBoard
  2. Spécifiez un répertoire de journaux
  3. Transmettez le rappel TensorBoard à Model.fit () de Keras.

TensorBoard lit les données de journal à partir de la hiérarchie des répertoires de journaux. Dans ce notebook, le répertoire racine du journal est logs/scalars , suffixé par un sous-répertoire horodaté. Le sous-répertoire horodaté vous permet d'identifier et de sélectionner facilement les exécutions d'entraînement lorsque vous utilisez TensorBoard et l'itération sur votre modèle.

 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

Examen des pertes à l'aide de TensorBoard

Maintenant, démarrez TensorBoard, en spécifiant le répertoire de journal racine que vous avez utilisé ci-dessus.

Attendez quelques secondes que l'interface utilisateur de TensorBoard démarre.

 %tensorboard --logdir logs/scalars
 

Vous pouvez voir TensorBoard afficher le message "Aucun tableau de bord n'est actif pour l'ensemble de données actuel". C'est parce que les données de journalisation initiales n'ont pas encore été enregistrées. Au fur et à mesure que l'entraînement progresse, le modèle Keras commencera à enregistrer les données. TensorBoard actualisera périodiquement et vous montrera vos métriques scalaires. Si vous êtes impatient, vous pouvez appuyer sur la flèche Actualiser en haut à droite.

Pendant que vous observez la progression de la formation, notez comment la perte de formation et de validation diminue rapidement, puis reste stable. En fait, vous auriez pu arrêter l'entraînement après 25 époques, car l'entraînement ne s'est pas beaucoup amélioré après ce point.

Survolez le graphique pour voir des points de données spécifiques. Vous pouvez également essayer de zoomer avec votre souris ou d'en sélectionner une partie pour afficher plus de détails.

Remarquez le sélecteur "Runs" sur la gauche. Un "run" représente un ensemble de logs d'un cycle de formation, dans ce cas le résultat de Model.fit (). Les développeurs ont généralement de très nombreuses exécutions, au fur et à mesure qu'ils expérimentent et développent leur modèle au fil du temps.

Utilisez le sélecteur d'exécutions pour choisir des exécutions spécifiques, ou choisissez uniquement l'entraînement ou la validation. La comparaison des exécutions vous aidera à évaluer la version de votre code qui résout le mieux votre problème.

Ok, le graphique de perte de TensorBoard démontre que la perte a constamment diminué pour la formation et la validation, puis s'est stabilisée. Cela signifie que les métriques du modèle sont probablement très bonnes! Maintenant, voyez comment le modèle se comporte réellement dans la vraie vie.

Compte tenu des données d'entrée (60, 25, 2), la ligne y = 0,5x + 2 devrait donner (32, 14,5, 3). Le modèle est-il d'accord?

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

Pas mal!

Journalisation des scalaires personnalisés

Que faire si vous souhaitez enregistrer des valeurs personnalisées, telles qu'un taux d'apprentissage dynamique ? Pour ce faire, vous devez utiliser l'API TensorFlow Summary.

Reconditionnez le modèle de régression et enregistrez un taux d'apprentissage personnalisé. Voici comment:

  1. Créez un enregistreur de fichiers à l'aide de tf.summary.create_file_writer() .
  2. Définissez une fonction de taux d'apprentissage personnalisée. Cela sera transmis au rappel Keras LearningRateScheduler .
  3. Dans la fonction de taux d'apprentissage, utilisez tf.summary.scalar() pour enregistrer le taux d'apprentissage personnalisé.
  4. Passez le rappel LearningRateScheduler à Model.fit ().

En général, pour enregistrer un scalaire personnalisé, vous devez utiliser tf.summary.scalar() avec un enregistreur de fichiers. Le rédacteur de fichier est responsable de l'écriture des données pour cette exécution dans le répertoire spécifié et est implicitement utilisé lorsque vous utilisez la fonction 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],
)
 

Regardons à nouveau TensorBoard.

 %tensorboard --logdir logs/scalars
 

En utilisant le sélecteur "Exécutions" sur la gauche, notez que vous avez une exécution <timestamp>/metrics . La sélection de cette course affiche un graphique «taux d'apprentissage» qui vous permet de vérifier la progression du taux d'apprentissage pendant cette course.

Vous pouvez également comparer les courbes de perte d'entraînement et de validation de cette exécution à vos exécutions précédentes.

Comment fonctionne ce modèle?

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