Come creare dei checkpoint in un modello di deep learning

I modelli di deep learning possono richiedere ore, giorni o addirittura settimane per essere addestrati. Se l'allenamento viene interrotto inaspettatamente, puoi perdere molto lavoro.

In questo post scoprirai come creare dei checkpoint dei tuoi modelli di deep learning durante l'addestramento in Python usando la libreria Keras.

Abbiamo deciso di scrivere questo articolo proprio perchè qualche giorno fa ci è saltata la corrente e abbiamo perso i dati di un allenamento che andava avanti da 7 ore. Risultato finale 7 ore perse. Ma non vogliamo che ti succeda anche a te, proprio per questo segui attentamente l'articolo e imparerai a

creare dei checkpoints mentre alleni un modello di deep learning

Come creare dei checkpoint in un modello di deep learning

Cosa è un Checkpoint nei modelli di deep learning?

Il checkpoint dell'applicazione è una tecnica di "salvataggio dei risultati temporanei" per processi di lunga durata. In questo approccio, viene acquisita un'istantanea dello stato del sistema in caso di guasto del sistema. Se c'è un problema, non tutto è perduto. Il checkpoint può essere utilizzato direttamente o come punto di partenza per un nuovo allenamento riprendendo da dove si era interrotto.

Quando si addestrano modelli di deep learning, il punto di checkpoint sono i pesi del modello. Questi pesi possono essere utilizzati per fare previsioni così com'è o come base per la formazione continua.

La libreria Keras fornisce una funzionalità di checkpoint tramite un'API di callback .

La classe di callback ModelCheckpoint consente di definire dove eseguire il checkpoint dei pesi del modello, come assegnare un nome al file e in quali circostanze creare un checkpoint del modello.

L'API consente di specificare quale metrica monitorare, ad esempio la perdita o l'accuratezza del set di dati di addestramento o convalida. È possibile specificare se cercare un miglioramento per massimizzare o ridurre al minimo il punteggio. Infine, il nome file che usi per memorizzare i pesi può includere variabili come il numero di epoch o la metrica.

Il ModelCheckpoint può quindi essere passato al processo di addestramento quando si chiama la funzione fit() sul modello.

Nota che potrebbe essere necessario installare la libreria h5py per emettere pesi di rete in formato HDF5.

Come usare un Checkpoint nei modelli di deep learning?

Un buon uso del checkpoint è quello di produrre i pesi del modello ogni volta che si osserva un miglioramento durante l'allenamento.

Detto in parole semplici ogni volta che il modello migliora lo salviamo, e ripartiamo da li.

L'esempio seguente crea una piccola rete neurale per l'insorgenza del problema di classificazione binaria del diabete. L'esempio presuppone che il file diabetes.csv si trovi nella directory di lavoro. Scaricalo premendo qui sotto.

Dataset_Diabete

.csv

Scarica CSV • 23KB

L'esempio utilizza il 33% dei dati per la convalida.

Il checkpoint è impostato per salvare i pesi della rete solo quando c'è un miglioramento nell'accuratezza della classificazione sul set di dati di convalida

(monitor='val_accuracy' e mode='max'). 

I pesi sono memorizzati in un file che include il punteggio nel nome del file

weights-improvement-{val_accuracy=.2f}.hdf5

Come creare dei checkpoints in un modello di deep learning con Python

Crea un nuovo file python e incolla il codice che segue

# Creiamo dei checkpoint solo quando il modello migliora
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import ModelCheckpoint
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
seed = 42
tf.random.set_seed(seed)

# dataset
dataset = np.loadtxt("diabetes.csv", delimiter=",")

# Dividiamo in input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]

# model
model = Sequential()
model.add(Dense(12, input_shape=(8,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compiliamo il modello
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# checkpoint
filepath="weights-improvement-{epoch:02d}-{val_accuracy:.2f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_accuracy', verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]

# Allenamento
model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list, verbose=0)

L'esecuzione dell'esempio produce il seguente output (troncato):

Epoch 00134: val_accuracy did not improve
Epoch 00135: val_accuracy did not improve
Epoch 00136: val_accuracy did not improve
Epoch 00137: val_accuracy did not improve
Epoch 00138: val_accuracy did not improve
Epoch 00139: val_accuracy did not improve
Epoch 00140: val_accuracy improved from 0.83465 to 0.83858, saving model to weights-improvement-140-0.84.hdf5
Epoch 00141: val_accuracy did not improve
Epoch 00142: val_accuracy did not improve
Epoch 00143: val_accuracy did not improve
Epoch 00144: val_accuracy did not improve
Epoch 00145: val_accuracy did not improve
Epoch 00146: val_accuracy improved from 0.83858 to 0.84252, saving model to weights-improvement-146-0.84.hdf5
Epoch 00147: val_accuracy did not improve
Epoch 00148: val_accuracy improved from 0.84252 to 0.84252, saving model to weights-improvement-148-0.84.hdf5
Epoch 00149: val_accuracy did not improve

Vedrai un certo numero di file nella tua directory di lavoro contenenti i pesi di rete in formato HDF5. Per esempio:

...
weights-improvement-53-0.76.hdf5
weights-improvement-71-0.76.hdf5
weights-improvement-77-0.78.hdf5
weights-improvement-99-0.78.hdf5

Questa è una strategia di checkpoint molto semplice.

Potrebbe creare molti file di checkpoint non necessari se l'accuratezza della convalida si sposta su e giù durante le epoch di addestramento. Tuttavia, ti garantirà un'istantanea del miglior modello scoperto durante la tua corsa.

Checkpoint del miglior modello di deep learning

Una strategia di checkpoint più semplice consiste nel salvare i pesi del modello nello stesso file se e solo se l'accuratezza della convalida migliora.

Questo può essere fatto facilmente usando lo stesso codice dall'alto e cambiando il nome del file di output da correggere (escluse le informazioni sul punteggio o sull'epoca).

In questo caso, i pesi del modello vengono scritti nel file “weights.best.hdf5” solo se l'accuratezza della classificazione del modello sul dataset di validazione migliora rispetto alla migliore vista finora.

# Creiamo dei checkpoint solo quando il modello migliora
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import ModelCheckpoint
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
seed = 42
tf.random.set_seed(seed)

# dataset
dataset = np.loadtxt("diabetes.csv", delimiter=",")

# Dividiamo in input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]

# model
model = Sequential()
model.add(Dense(12, input_shape=(8,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compiliamo il modello
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# checkpoint
filepath="weights.best.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_accuracy', verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]

# Allenamento
model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list, verbose=0)

L'esecuzione di questo esempio fornisce il seguente output (troncato per brevità):

Epoch 00139: val_accuracy improved from 0.79134 to 0.79134, saving model to weights.best.hdf5
Epoch 00140: val_accuracy did not improve
Epoch 00141: val_accuracy did not improve
Epoch 00142: val_accuracy did not improve
Epoch 00143: val_accuracy did not improve
Epoch 00144: val_accuracy improved from 0.79134 to 0.79528, saving model to weights.best.hdf5
Epoch 00145: val_accuracy improved from 0.79528 to 0.79528, saving model to weights.best.hdf5
Epoch 00146: val_accuracy did not improve
Epoch 00147: val_accuracy did not improve
Epoch 00148: val_accuracy did not improve
Epoch 00149: val_accuracy did not improve

Dovresti vedere il file del peso nella tua directory locale.

weights.best.hdf5

Questa è una pratica strategia di checkpoint da utilizzare sempre durante i tuoi esperimenti.

Garantirà che il tuo modello migliore venga salvato per la corsa per poterlo utilizzare in seguito, se lo desideri. Evita di dover includere codice per tenere traccia e serializzare manualmente il modello migliore durante l'addestramento.

EarlyStopping insieme a Checkpoint

Negli esempi sopra, è stato fatto un tentativo di adattare il tuo modello con 150 epoch. In realtà non è facile dire quante epoch occorrono per addestrare il proprio modello. Un modo per affrontare questo problema è sovrastimare il numero di epoch. Ma questo potrebbe richiedere molto tempo. Dopotutto, se stai controllando solo il modello migliore, potresti scoprire che nel corso delle diverse migliaia di epoch hai già ottenuto il modello migliore nelle prime cento epoch e in seguito non vengono più effettuati punti di controllo.

È abbastanza comune utilizzare il callback ModelCheckpoint insieme a EarlyStopping. Aiuta a interrompere l'allenamento una volta che non si vede alcun miglioramento metrico per diverse epoch. L'esempio seguente aggiunge il callback esper interrompere anticipatamente l'allenamento una volta che non vede migliorare l'accuratezza della convalida per cinque epoch consecutive:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
import matplotlib.pyplot as plt
import numpy as np

# dataset
dataset = np.loadtxt("pima-indians-diabetes.csv", delimiter=",")
#  input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]

# modello
model = Sequential()
model.add(Dense(12, input_shape=(8,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# Compiliamo il modello
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# checkpoint
filepath="weights.best.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='val_accuracy', verbose=1, save_best_only=True, mode='max')
es = EarlyStopping(monitor='val_accuracy', patience=5)
callbacks_list = [checkpoint, es]

# Allenamento
model.fit(X, Y, validation_split=0.33, epochs=150, batch_size=10, callbacks=callbacks_list, verbose=0)

L'esecuzione di questo esempio fornisce il seguente output:

Epoch 1: val_accuracy improved from -inf to 0.51969, saving model to weights.best.hdf5
Epoch 2: val_accuracy did not improve from 0.51969
Epoch 3: val_accuracy improved from 0.51969 to 0.54724, saving model to weights.best.hdf5
Epoch 4: val_accuracy improved from 0.54724 to 0.61417, saving model to weights.best.hdf5
Epoch 5: val_accuracy did not improve from 0.61417
Epoch 6: val_accuracy did not improve from 0.61417
Epoch 7: val_accuracy improved from 0.61417 to 0.66142, saving model to weights.best.hdf5
Epoch 8: val_accuracy did not improve from 0.66142
Epoch 9: val_accuracy did not improve from 0.66142
Epoch 10: val_accuracy improved from 0.66142 to 0.68504, saving model to weights.best.hdf5
Epoch 11: val_accuracy did not improve from 0.68504
Epoch 12: val_accuracy did not improve from 0.68504
Epoch 13: val_accuracy did not improve from 0.68504
Epoch 14: val_accuracy did not improve from 0.68504
Epoch 15: val_accuracy improved from 0.68504 to 0.69685, saving model to weights.best.hdf5
Epoch 16: val_accuracy improved from 0.69685 to 0.71260, saving model to weights.best.hdf5
Epoch 17: val_accuracy improved from 0.71260 to 0.72047, saving model to weights.best.hdf5
Epoch 18: val_accuracy did not improve from 0.72047
Epoch 19: val_accuracy did not improve from 0.72047
Epoch 20: val_accuracy did not improve from 0.72047
Epoch 21: val_accuracy did not improve from 0.72047
Epoch 22: val_accuracy did not improve from 0.72047

Questo processo di addestramento si è interrotto dopo l'epoca 22 poiché non è stata raggiunta una migliore precisione nelle ultime cinque epoch.

Caricamento di un modello di rete neurale con checkpoint

Ora che hai visto come eseguire il checkpoint dei tuoi modelli di deep learning durante l'allenamento, devi rivedere come caricare e utilizzare un modello con checkpoint.

Il checkpoint include solo i pesi del modello. Presuppone che tu conosca la struttura della rete. Anche questo può essere serializzato in un file in formato JSON o YAML.

Nell'esempio seguente, la struttura del modello è nota e i pesi migliori vengono caricati dall'esperimento precedente, archiviati nella directory di lavoro nel file weights.best.hdf5.

Il modello viene quindi utilizzato per fare previsioni sull'intero set di dati.

# come caricare un checkpoint
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import ModelCheckpoint
import matplotlib.pyplot as plt
import numpy as np

# modello
model = Sequential()
model.add(Dense(12, input_shape=(8,), activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

# carichiamo i pesi ( weights )
model.load_weights("weights.best.hdf5")

# Compiliamo il modello 
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print("Created model and loaded weights from file")

# dataset
dataset = np.loadtxt("pima-indians-diabetes.csv", delimiter=",")

# input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]

#  accuracy 
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))

L'esecuzione dell'esempio produce il seguente output:

Created model and loaded weights from file
acc: 77.73%

Riepilogo su Come creare dei checkpoints in un modello di deep learning

In questo post, hai scoperto l'importanza di controllare i modelli di deep learning per lunghe sessioni di allenamento.

Hai imparato due strategie di check-point che puoi utilizzare nel tuo prossimo progetto di deep learning:

1. Miglioramenti del modello di checkpoint

2. Solo miglior modello di Checkpoint

Hai anche imparato a caricare un modello con checkpoint e fare previsioni.

Hai domande sul checkpoint dei modelli di deep learning o su questo post? Poni le tue domande nei commenti e farò del mio meglio per rispondere.