Come valutare modelli di machine learning utilizzando TensorBoard con TensorFlow

Una parte fondamentale della pipeline di machine learning è trovare un modello che rappresenti al meglio i tuoi dati e funzioni in modo efficace sui set di dati futuri.

In virtù della loro stessa natura, i modelli di Machine Learning migliorano in modo iterativo. Non esiste quasi nessun modello di machine learning che venga addestrato perfettamente al primo tentativo. Di solito sono necessarie diverse iterazioni.

Come puoi immaginare, questi modelli devono essere valutati per migliorarli. In altre parole, un modello di machine learning deve essere valutato prima di poter essere migliorato.

TensorBoard è stato sviluppato per offrire agli ingegneri del machine learning uno sguardo più approfondito sulle prestazioni dei loro modelli.

Cos'è TensorBoard?

La funzionalità di base di TensorBoard è fornire le metriche e le visualizzazioni necessarie per il flusso di lavoro di Machine Learning. Consente di monitorare la perdita e la precisione, visualizzare e valutare i grafici degli errori ed eseguire molte altre attività.

TensorBoard utilizza concetti grafici per rappresentare il flusso di dati e le azioni del modello, consentendo al tempo stesso di vedere le topologie dei grafici e i parametri di modelli complessi ed enormi. Ha anche un'interfaccia utente molto intuitiva e di base.

In questo tutorial analizzerai e valuterai i risultati su un modello di machine learning addestrato. Il modello che utilizzerai verrà addestrato per un set di dati con cifre scritte a mano MNIST. Utilizza il database MNIST (Modified National Institute of Standards and Technology), che contiene un'ampia raccolta di cifre scritte a mano. Questo set di dati viene comunemente utilizzato per addestrare vari sistemi di elaborazione delle immagini.

Prerequisiti

Per completare questo tutorial avrai bisogno di:

1. Comprensione fondamentale del funzionamento dei modelli di Machine Learning.
2. Un nuovo notebook Google Colab per eseguire il codice Python nel tuo Google Drive. Puoi configurarlo seguendo questo tutorial.

Passaggio 1: come configurare TensorBoard

Poiché TensorBoard viene fornito automaticamente con TensorFlow, non è necessario installarlo utilizzando pip in questa configurazione. Inoltre, poiché TensorFlow viene preinstallato quando crei un nuovo notebook su Google Colab, anche TensorBoard viene preinstallato. Pertanto, quando imposti TensorBoard, devi solo importare tensorflow .

• Carica l'estensione tensorboard utilizzando la magia %load_ext nel tuo notebook.
• Dopo aver fatto ciò, importa le librerie necessarie (ovvero, tensorflow e datetime) come mostrato di seguito:

%load_ext tensorboard

import tensorflow as tf
import datetime

A questo punto, hai importato con successo un'istanza di TensorBoard e l'hai configurata. Ora puoi iniziare.

Passaggio 2: come creare e addestrare il modello

In questo tutorial utilizzerai il set di dati MNIST, che include minuscole immagini in scala di grigi a cifra singola scritte a mano da 28 x 28 pixel. Il set di dati, che è uno dei set di dati preinstallati offerti da Keras, viene spesso utilizzato per sviluppare modelli di machine learning per il riconoscimento delle cifre.

• Crea un'istanza del set di dati e chiamala mnist.
• Suddividere i dati in set di treni e set di test. Un set di treni è un sottoinsieme dei dati originali utilizzato per addestrare il modello di machine learning mentre un set di test è il sottoinsieme utilizzato per verificare l'accuratezza del modello.
• Standardizza tutti i valori del tuo treno e dei set di test. Ciò implica normalizzare l'immagine nell'intervallo [0,1].
• Definisci una funzione che verrà utilizzata per addestrare il modello di machine learning sul tuo set di dati. Verrà utilizzato il modello Keras Sequenziale.

mnist = tf.keras.datasets.mnist

(x_train, y_train),(x_test, y_test) = mnist.load_data()

x_train, x_test = x_train/255.0, x_test/255.0

def create_model():
  return tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(512, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(10, activation='softmax')
  ])

Utilizzerai il modello Sequenziale Keras. Fondamentalmente, raggruppa una pila lineare di livelli in tf.keras.Model fornendo funzionalità di training e inferenza su questo modello.

Il livello .Flatten() appiattisce l'input senza influenzare la dimensione del batch. La forma di input in questo esempio è 28 x 28 poiché le immagini del set di dati sono immagini in scala di grigi di 28×28 pixel di cifre singole scritte a mano. Il primo strato .Dense() è un regolare strato NN densamente connesso.

La funzione di attivazione utilizzata è 'relu' e la dimensionalità del suo spazio di output è 512. Il livello .Dropout() rilascia parte dell'input con la frazione delle unità di input rilasciate in questo tutorial data come 0,2 .

Infine, come il primo, il secondo. Il livello Dense è anche il normale livello NN densamente connesso. La funzione di attivazione che stiamo utilizzando è "softmax" e la dimensionalità del suo spazio di output è dieci.

• Chiama la funzione definita per il modello in questo modo:
• Con la funzione definita chiamata, addestrare il modello con parametri adeguati.
• Utilizzando la libreria datatime importata in precedenza, posiziona i log in una sottodirectory con timestamp per consentire una facile selezione di diverse esecuzioni di training.

model = create_model()

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

I log sono importanti perché TensorBoard leggerà dai log per visualizzare le varie visualizzazioni rispetto all'ora in quel momento.

log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

• Infine, addestra (o adatta) il modello di machine learning su tre epoche (iterazioni).

model.fit(x=x_train, 
          y=y_train, 
          epochs=3, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])

Passaggio 3: come valutare il modello

Per avviare TensorBoard nel tuo notebook, esegui il codice seguente:

%tensorboard --logdir logs/fit

Ora puoi visualizzare i dashboard che mostrano le metriche per il modello nelle schede in alto e valutare e migliorare di conseguenza i tuoi modelli di machine learning.

Passaggio 4 - Come migliorare il modello

Poiché lo scopo della valutazione dei modelli di machine learning è acquisire informazioni migliori per migliorare l'algoritmo, è fondamentale migliorare il nostro modello. Con queste immagini, ora puoi vedere le prestazioni approfondite del modello.

• Il dashboard Scalars può essere utilizzato per osservare altri valori scalari come l'efficienza dell'addestramento e il tasso di apprendimento. Dimostra come i parametri e le perdite fluttuano in ogni epoca.
• Come suggerisce il nome, la dashboard Graphs viene utilizzata per visualizzare il tuo modello.

Per migliorare questo modello, regolerai il numero di epoche da 3 a 6 e vedrai come si comporta il modello.

In generale, il numero di epoche è il numero di iterazioni sull'intero set di dati di addestramento su cui viene addestrato il modello di machine learning.

Intuitivamente, l'aumento di questo numero migliora quasi sempre le prestazioni del modello di machine learning. Per fare ciò, eseguirai il codice come segue:

model.fit(x=x_train, 
          y=y_train, 
          epochs=6, 
          validation_data=(x_test, y_test), 
          callbacks=[tensorboard_callback])

Con la modifica che abbiamo apportato, puoi quindi generare un altro TensorBoard come questo:

%tensorboard --logdir logs/fit

Dalle immagini appena generate, puoi vedere che c'è un notevole miglioramento nelle prestazioni del modello.

Conclusione

In questo articolo hai imparato come utilizzare TensorBoard per valutare e migliorare le prestazioni del tuo modello di Machine Learning.

Se a questo punto hai domande sulla differenza tra TensorBoard e TensorFlow Metrics Analysis (TFMA), questa è una preoccupazione legittima. Dopotutto, entrambi sono strumenti per fornire le misurazioni e le visualizzazioni necessarie durante il flusso di lavoro di Machine Learning.

Ma è importante notare che ciascuno di questi strumenti viene utilizzato in fasi distinte del processo di sviluppo. Fondamentalmente, TensorBoard viene utilizzato per analizzare il processo di formazione stesso, mentre TFMA si occupa dell'analisi del modello addestrato "finito".

Infine, condivido i miei scritti su Twitter se ti è piaciuto questo articolo e vuoi vederne di più.

Grazie per aver letto :)