 Visualizza su TensorFlow.org |  Esegui in Google Colab |  Visualizza la fonte su GitHub |
Panoramica
L'apprendimento automatico implica invariabilmente la comprensione di metriche chiave come la perdita e il modo in cui cambiano man mano che la formazione progredisce. Queste metriche possono aiutare a capire se si sta overfitting , per esempio, o se ti alleni inutilmente per troppo tempo. Potresti voler confrontare queste metriche tra diverse esecuzioni di addestramento per aiutare a eseguire il debug e migliorare il tuo modello.
Di TensorBoard scalari Dashboard consente di visualizzare queste metriche utilizzando una semplice API con il minimo sforzo. Questo tutorial presenta esempi di base per aiutarti a imparare a usare queste API con TensorBoard durante lo sviluppo del tuo modello Keras. Imparerai come utilizzare il callback Keras TensorBoard e le API di riepilogo TensorFlow per visualizzare scalari predefiniti e personalizzati.
Impostare
# 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
Imposta i dati per una semplice regressione
Adesso stai andando ad utilizzare Keras per calcolare una regressione, cioè, trovare la migliore linea di regressione di un insieme di dati appaiati. (Durante l'utilizzo di reti neurali e discesa del gradiente è eccessivo per questo tipo di problema , lo fa fare per un esempio molto facile da capire.)
Hai intenzione di utilizzare TensorBoard per osservare come il cambiamento di formazione e la perdita di prova attraverso le epoche. Si spera che l'allenamento e la perdita di test diminuiscano nel tempo per poi rimanere stabili.
In primo luogo, generare 1000 punti dati approssimativamente lungo la linea y = 0.5x + 2. Suddividi questi punti dati in set di addestramento e test. La tua speranza è che la rete neurale impari questa relazione.
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:]
Addestramento del modello e registrazione della perdita
Ora sei pronto per definire, addestrare e valutare il tuo modello.
Per accedere lo scalare economico come ci si allena, si farà il seguente:
- Creare il Keras callback TensorBoard
- Specificare una directory di registro
- Passare il callback TensorBoard a Keras' Model.fit () .
TensorBoard legge i dati di registro dalla gerarchia di directory di registro. In questo notebook, la directory di registro principale è logs/scalars , suffisso da una sottodirectory timestamp. La sottodirectory con timestamp consente di identificare e selezionare facilmente le esecuzioni di addestramento mentre si utilizza TensorBoard e si esegue l'iterazione sul modello.
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
Esaminare la perdita utilizzando TensorBoard
Ora, avvia TensorBoard, specificando la directory del registro principale che hai usato sopra.
Attendi qualche secondo che l'interfaccia utente di TensorBoard si avvii.
%tensorboard --logdir logs/scalars
È possibile che TensorBoard visualizzi il messaggio "Nessun dashboard attivo per il set di dati corrente". Questo perché i dati di registrazione iniziale non sono ancora stati salvati. Con l'avanzare dell'addestramento, il modello Keras inizierà a registrare i dati. TensorBoard aggiornerà periodicamente e ti mostrerà le tue metriche scalari. Se sei impaziente, puoi toccare la freccia Aggiorna in alto a destra.
Mentre osservi il progresso dell'allenamento, nota come sia la perdita di addestramento che quella di convalida diminuiscano rapidamente, per poi rimanere stabili. In effetti, avresti potuto interrompere l'allenamento dopo 25 epoche, perché l'allenamento non è migliorato molto dopo quel punto.
Passa il mouse sopra il grafico per vedere punti dati specifici. Puoi anche provare a ingrandire con il mouse o a selezionarne una parte per visualizzare maggiori dettagli.
Notare il selettore "Esecuzioni" a sinistra. Una "corsa" rappresenta un insieme di registri da un ciclo di allenamento, in questo caso il risultato di Model.fit(). Gli sviluppatori in genere hanno molte, molte esecuzioni, mentre sperimentano e sviluppano il loro modello nel tempo.
Utilizza il selettore delle corse per scegliere corse specifiche oppure scegli solo tra allenamento o convalida. Il confronto delle esecuzioni ti aiuterà a valutare quale versione del tuo codice sta risolvendo meglio il tuo problema.
Ok, il grafico della perdita di TensorBoard dimostra che la perdita è costantemente diminuita sia per l'addestramento che per la convalida e poi si è stabilizzata. Ciò significa che le metriche del modello sono probabilmente molto buone! Ora guarda come si comporta effettivamente il modello nella vita reale.
Considerando i dati di ingresso (60, 25, 2), la retta y = 0.5x + 2 dovrebbe produrre (32, 14.5, 3). Il modello è d'accordo?
print(model.predict([60, 25, 2]))
# True values to compare predictions against:
# [[32.0]
# [14.5]
# [ 3.0]]
[[32.234306 ] [14.5974245] [ 3.0074697]]
Non male!
Registrazione scalari personalizzati
Che cosa succede se si desidera registrare valori personalizzati, come ad esempio un tasso di apprendimento dinamico ? Per fare ciò, è necessario utilizzare l'API di riepilogo TensorFlow.
Riaddestrare il modello di regressione e registrare un tasso di apprendimento personalizzato. Ecco come:
- Creare un file scrittore, utilizzando
tf.summary.create_file_writer(). - Definire una funzione di tasso di apprendimento personalizzata. Questo sarà passato al Keras LearningRateScheduler callback.
- All'interno della funzione tasso di apprendimento, uso
tf.summary.scalar()per registrare il tasso di apprendimento personalizzato. - Passa il callback LearningRateScheduler a Model.fit().
In generale, per registrare uno scalare personalizzato, è necessario utilizzare tf.summary.scalar() con uno scrittore di file. Lo scrittore file è responsabile per la scrittura dei dati per questa esecuzione alla directory specificata ed è implicitamente utilizzato quando si utilizza il 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],
)
Diamo un'occhiata di nuovo a TensorBoard.
%tensorboard --logdir logs/scalars
Utilizzando il selettore "corre" sulla sinistra, si noti che si dispone di una <timestamp>/metrics run. Selezionando questa corsa viene visualizzato un grafico "tasso di apprendimento" che consente di verificare la progressione della velocità di apprendimento durante questa corsa.
Puoi anche confrontare le curve di perdita di allenamento e convalida di questa corsa con le tue corse precedenti. Potresti anche notare che il programma del tasso di apprendimento ha restituito valori discreti, a seconda dell'epoca, ma il grafico del tasso di apprendimento potrebbe apparire uniforme. TensorBoard ha un parametro di livellamento che potrebbe essere necessario abbassare a zero per vedere i valori non livellati.
Come funziona questo modello?
print(model.predict([60, 25, 2]))
# True values to compare predictions against:
# [[32.0]
# [14.5]
# [ 3.0]]
[[32.234013 ] [14.5973015] [ 3.0074618]]