 Voir sur TensorFlow.org |  Exécuter dans Google Colab |  Voir la source sur GitHub |
Aperçu
L'apprentissage automatique implique invariablement de comprendre les métriques clés telles que la perte et comment elles changent au fur et à mesure que la formation progresse. Ces mesures peuvent vous aider à comprendre si vous surapprentissage , par exemple, ou si vous vous entraînez inutilement 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.
Tableau de bord Scalaires de TensorBoard vous permet de visualiser ces paramètres en utilisant une API simple avec très peu d' effort. Ce tutoriel 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 de résumé TensorFlow 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 les données pour une régression simple
Vous allez maintenant utiliser Keras pour calculer une régression, à savoir trouver la meilleure ligne d'ajustement pour un ensemble de données appariées. (Lors de l' utilisation des réseaux de neurones et descente de gradient est surpuissant pour ce genre de problème , il ne fait un très facile à comprendre par exemple.)
Vous allez utiliser TensorBoard pour observer comment les changements de formation et la perte d'essai sur époques. Espérons que vous verrez la perte d'entraînement et de test diminuer au fil du temps, puis rester stable.
En premier lieu , 1000 générer des points de données à peu près le long de la ligne y = 0,5x + 2. Divisez ces points de données en ensembles d'apprentissage et de test. Votre espoir est que le réseau neuronal apprend 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:]
Entraînement du modèle et perte de journalisation
Vous êtes maintenant prêt à définir, entraîner et évaluer votre modèle.
Pour connecter le scalaire de perte que vous vous entraînez, vous effectuez les opérations suivantes:
- Créez le Keras rappel TensorBoard
- Spécifier un répertoire de journal
- Passez le rappel à TensorBoard de Keras Model.fit () .
TensorBoard lit les données des journaux à partir de la hiérarchie des répertoires des journaux. Dans ce bloc - notes, le répertoire des journaux racine est logs/scalars , par un sous - répertoire suffixées horodatées. Le sous-répertoire horodaté vous permet d'identifier et de sélectionner facilement des entraînements lorsque vous utilisez TensorBoard et d'itérer 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(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
Examiner la perte à 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.
En observant la progression de l'entraînement, notez comment la perte d'entraînement et de validation diminuent rapidement, puis restent stables. 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 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 journaux d'un cycle d'entraînement, 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 de courses pour choisir des courses spécifiques, ou choisissez uniquement l'entraînement ou la validation. La comparaison des exécutions vous aidera à évaluer quelle version de votre code résout le mieux votre problème.
D'accord, le graphique de perte de TensorBoard montre que la perte a systématiquement diminué à la fois pour l'entraînement et la validation, puis s'est stabilisée. Cela signifie que les métriques du modèle sont probablement très bonnes ! Voyez maintenant comment le modèle se comporte réellement dans la vraie vie.
Compte tenu de la donnée d'entrée (60, 25, 2), la ligne y = 0,5x + 2 devrait produire (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 voulez enregistrer des valeurs personnalisées, comme un taux d'apprentissage dynamique ? Pour ce faire, vous devez utiliser l'API de résumé TensorFlow.
Réentraînez le modèle de régression et enregistrez un taux d'apprentissage personnalisé. Voici comment:
- Créer un écrivain de fichier, en utilisant
tf.summary.create_file_writer(). - Définissez une fonction de taux d'apprentissage personnalisée. Ce sera transmis à la Keras LearningRateScheduler rappel.
- A l' intérieur de la fonction de taux d'apprentissage, l' utilisation
tf.summary.scalar()pour se connecter le taux d'apprentissage personnalisé. - Transmettez le rappel LearningRateScheduler à Model.fit().
En général, pour connecter un scalaire personnalisé, vous devez utiliser tf.summary.scalar() avec un écrivain de fichier. L'auteur 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 le 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
Utilisation du sélecteur « Runs » à gauche, notez que vous avez un <timestamp>/metrics run. 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 course avec vos courses précédentes. Vous remarquerez peut-être également que le calendrier du taux d'apprentissage a renvoyé des valeurs discrètes, selon l'époque, mais le tracé du taux d'apprentissage peut sembler lisse. TensorBoard a un paramètre de lissage que vous devrez peut-être réduire à zéro pour voir les valeurs non lissées.
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]]