top of page

Come salvare e caricare il tuo modello di deep learning o apprendimento profondo

Keras è una libreria Python semplice e potente per il deep learning.

Dato che l'addestramento dei modelli di deep learning può richiedere ore, giorni e persino settimane, è importante sapere come salvarli e caricarli dal disco.


In questo post scoprirai come salvare i tuoi modelli Keras su file e caricarli di nuovo per fare previsioni.



Come salvare e caricare il tuo modello di deep learning o apprendimento profondo
Come salvare e caricare il tuo modello di deep learning o apprendimento profondo


Dopo aver letto questo tutorial saprai:

  • Come salvare i pesi del modello e l'architettura del modello in file separati.

  • Come salvare l'architettura del modello in formato YAML e JSON.

  • Come salvare i pesi e l'architettura del modello in un unico file per un uso successivo.


Prerequisiti Tutorial:



Introduzione


Keras separa le preoccupazioni relative al salvataggio dell'architettura del modello e al salvataggio del peso del modello.


I pesi dei modelli vengono salvati nel formato HDF5 . Questo è un formato griglia ideale per memorizzare matrici di numeri multidimensionali.


La struttura del modello può essere descritta e salvata utilizzando due diversi formati: JSON e YAML.


In questo post esamineremo due esempi di salvataggio e caricamento del modello su file:

  • Salva modello in JSON.

  • Salva modello in YAML.

Ogni esempio dimostrerà anche il salvataggio e il caricamento dei pesi del modello su file formattati HDF5.


Gli esempi utilizzeranno la stessa semplice rete addestrata sull'inizio del set di dati di classificazione binaria del diabete da parte degli indiani Pima. Questo è un piccolo set di dati che contiene tutti i dati numerici ed è facile da lavorare.


Puoi scaricare questo set di dati e inserirlo nella tua directory di lavoro con il nome del file " pima-indians-diabetes.csv " ( scarica da qui ).



Nota : il salvataggio dei modelli richiede l'installazione della libreria h5py. Puoi installarlo facilmente come segue:

sudo pip install h5py #se hai python <3
sudo pip3 install h5py #se hai python >=3
!pip install h5py #se stai lavorando su Coolab


Salva il tuo modello di rete neurale in JSON

JSON è un semplice formato di file per descrivere i dati in modo gerarchico.

Keras offre la possibilità di descrivere qualsiasi modello utilizzando il formato JSON con una funzione to_json() . Questo può essere salvato su file e successivamente caricato tramite la funzione model_from_json() che creerà un nuovo modello dalla specifica JSON.


I pesi vengono salvati direttamente dal modello utilizzando la funzione save_weights() e successivamente caricati utilizzando la funzione load_weights() simmetrica .

L'esempio seguente addestra e valuta un modello semplice sul set di dati degli indiani Pima. Il modello viene quindi convertito in formato JSON e scritto in model.json nella directory locale. I pesi di rete vengono scritti in model.h5 nella directory locale.


I dati del modello e del peso vengono caricati dai file salvati e viene creato un nuovo modello. È importante compilare il modello caricato prima che venga utilizzato. In questo modo le previsioni effettuate utilizzando il modello possono utilizzare il calcolo efficiente appropriato dal backend Keras.

Il modello viene valutato allo stesso modo stampando lo stesso punteggio di valutazione.



# Salviamo il nostro modello
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import numpy
import os
# fissiamo un seme per essere in grado di replicare i nostri output
numpy.random.seed(7)
# Carichiamo il Dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
#dividiamo le variabili in input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]
# Creiamo il nostro modellino
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compiliamolo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Alleniamolo
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# Valutiamo il modello
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
 
# Modello ->> file json
model_json = model.to_json()
with open("model.json", "w") as json_file:
    json_file.write(model_json)
# Pesi Modello ->> fil h5
model.save_weights("model.h5")
print("Saved model to disk")
 
# per ricaricarli quando ti serviranno...
 
# Carichiamo il file json
json_file = open('mdel.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
# Carichiamo i pesi
loaded_model.load_weights("model.h5")
print("Loaded model from disk")
 
# Rivalutiamo il modello
loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
score = loaded_model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))

Nota : i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione, o delle differenze nella precisione numerica. Considera di eseguire l'esempio alcune volte e confrontare il risultato medio.


L'esecuzione di questo esempio fornisce l'output seguente.


acc: 78.78%
Saved model to disk
Loaded model from disk
acc: 78.78%


Salva il tuo modello di rete neurale su YAML

Questo esempio è più o meno lo stesso dell'esempio JSON precedente, tranne per il fatto che il formato YAML viene utilizzato per la specifica del modello.

Nota, questo esempio presuppone che tu abbia installato PyYAML 5, ad esempio:

1sudo pip install PyYAML

In questo esempio, il modello viene descritto utilizzando YAML, salvato nel file model.yaml e successivamente caricato in un nuovo modello tramite la funzione model_from_yaml() .

I pesi vengono gestiti come sopra nel formato HDF5 come model.h5 .



# Salviamo il nostro modello
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import numpy
import os
# fissiamo un seme per essere in grado di replicare i nostri output
numpy.random.seed(7)
# Carichiamo il Dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
#dividiamo le variabili in input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]
# Creiamo il nostro modellino
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compiliamolo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Alleniamolo
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# Valutiamo il modello
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
 
# Modello ->> file YAML
model_yaml = model.to_yaml()
with open("model.yaml", "w") as yaml_file:
    yaml_file.write(model_yaml)
# Pesi Modello ->> file HDF5
model.save_weights("model.h5")
print("Saved model to disk")
 
# per ricaricarli quando ti serviranno...
 
# Carichiamo il file YAML
yaml_file = open('model.yaml', 'r')
loaded_model_yaml = yaml_file.read()
yaml_file.close()
loaded_model = model_from_yaml(loaded_model_yaml)
# Carichiamo i nostri pesi
loaded_model.load_weights("model.h5")
print("Loaded model from disk")
 
# Rivalutiamo il modello
loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
score = loaded_model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))


Nota : i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione, o delle differenze nella precisione numerica. Considera di eseguire l'esempio alcune volte e confrontare il risultato medio.


L'esecuzione dell'esempio mostra il seguente output.


acc: 78.78%
Saved model to disk
Loaded model from disk
acc: 78.78%


Salva insieme pesi e architettura del modello

Keras supporta anche un'interfaccia più semplice per salvare insieme i pesi del modello e l'architettura del modello in un unico file H5.

Il salvataggio del modello in questo modo include tutto ciò che dobbiamo sapere sul modello, tra cui:

  • Pesi del modello.

  • Architettura del modello.

  • Dettagli della compilazione del modello (perdita e metriche).

  • Stato dell'ottimizzatore del modello.

Ciò significa che possiamo caricare e utilizzare direttamente il modello, senza doverlo ricompilare come abbiamo fatto negli esempi precedenti.

Nota : questo è il modo preferito per salvare e caricare il tuo modello Keras.

Come salvare un modello Keras

Puoi salvare il tuo modello chiamando la funzione save() sul modello e specificando il nome del file.

L'esempio seguente lo dimostra adattando prima un modello, valutandolo e salvandolo nel file model.h5 .



# Salviamo il nostro modello
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import numpy
import os
# fissiamo un seme per essere in grado di replicare i nostri output
numpy.random.seed(7)
# Carichiamo il Dataset
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",")
#dividiamo le variabili in input (X) e output (Y) 
X = dataset[:,0:8]
Y = dataset[:,8]
# Creiamo il nostro modellino
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compiliamolo
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Alleniamolo
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# Valutiamo il modello
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
# Salviamo modello e architettura della rete in un unico file
model.save("model.h5")
print("Saved model to disk")

Nota : i risultati possono variare a causa della natura stocastica dell'algoritmo o della procedura di valutazione, o delle differenze nella precisione numerica. Considera di eseguire l'esempio alcune volte e confrontare il risultato medio.


L'esecuzione dell'esempio si adatta al modello, riassume le prestazioni del modello sul set di dati di addestramento e salva il modello su file.


acc: 77.73%
Saved model to disk


Successivamente possiamo caricare questo modello da file e usarlo.


Come caricare un modello Keras

Il tuo modello salvato può quindi essere caricato in un secondo momento chiamando la funzione load_model() e passando il nome del file. La funzione restituisce il modello con la stessa architettura e pesi.

In questo caso, carichiamo il modello, riassumiamo l'architettura e la valutiamo sullo stesso set di dati per confermare che i pesi e l'architettura siano gli stessi.



# Importiamo le libreire per caricare il modello
from numpy import loadtxt
from keras.models import load_model
 
# Ricarichiamo il modello salvata
model = load_model('model.h5')
# Stampiamo li info base del modello
model.summary()
# Carichiamo il dataset
dataset = loadtxt("pima-indians-diabetes.csv", delimiter=",")
#  Dividiamo input e output
X = dataset[:,0:8]
Y = dataset[:,8]
# Valutiamo il modello 
score = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], score[1]*100))


L'esecuzione dell'esempio carica prima il modello, stampa un riepilogo dell'architettura del modello, quindi valuta il modello caricato sullo stesso set di dati.


Considera di eseguire l'esempio alcune volte e confrontare il risultato medio.

Il modello ottiene lo stesso punteggio di accuratezza che in questo caso è del 77%.



_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================
dense_1 (Dense)              (None, 12)                108       
_________________________________________________________________
dense_2 (Dense)              (None, 8)                 104       
_________________________________________________________________
dense_3 (Dense)              (None, 1)                 9         
=================================================
Total params: 221
Trainable params: 221
Non-trainable params: 0
_________________________________________________________________
 
acc: 77.73%



Riepilogo

In questo post, hai scoperto come serializzare i tuoi modelli di deep learning Keras.

Hai imparato come salvare i tuoi modelli addestrati su file e in seguito caricarli e usarli per fare previsioni.


Hai anche appreso che i pesi del modello possono essere facilmente archiviati utilizzando il formato HDF5 e che la struttura di rete può essere salvata in formato JSON o YAML.

Hai domande sul salvataggio dei tuoi modelli di deep learning o su questo post? Poni le tue domande nei commenti e faremo del nostro meglio per risponderti.


Comments

Rated 0 out of 5 stars.
No ratings yet

Add a rating
PCR (5).gif
PCR (4).gif
PCR.gif
PCR.gif
PCR.gif
PCR.gif