wake-up-neo.com

Keras: Wie speichert man das Modell und setzt das Training fort?

Ich habe ein Modell, das ich für 40 Epochen trainiert habe. Ich behielt Kontrollpunkte für jede Epoche und speicherte das Modell auch mit model.save(). Der Code für das Training lautet

n_units = 1000
model = Sequential()
model.add(LSTM(n_units, input_shape=(None, vec_size), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units))
model.add(Dropout(0.2))
model.add(Dense(vec_size, activation='linear'))
model.compile(loss='mean_squared_error', optimizer='adam')
# define the checkpoint
filepath="Word2vec-{Epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# fit the model
model.fit(x, y, epochs=40, batch_size=50, callbacks=callbacks_list)

Wenn Sie jedoch das Modell erneut laden und trainieren, beginnt es von vorn, als ob es noch nicht trainiert worden wäre. Der Verlust beginnt nicht beim letzten Training.

Was mich verwirrt, ist, wenn ich ein Modell mit einer neuen Modellstruktur und load_weight lade, funktioniert die model.predict() gut. Ich glaube also, dass die Modellgewichte geladen sind.

model = Sequential()
model.add(LSTM(n_units, input_shape=(None, vec_size), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units))
model.add(Dropout(0.2))
model.add(Dense(vec_size, activation='linear'))
filename = "Word2vec-39-0.0027.hdf5"
model.load_weights(filename)
model.compile(loss='mean_squared_error', optimizer='adam')

Wenn ich jedoch weiter trainiere mit 

filepath="Word2vec-{Epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# fit the model
model.fit(x, y, epochs=40, batch_size=50, callbacks=callbacks_list)

Der Verlust ist so hoch wie im Ausgangszustand.

Ich suchte und fand einige Beispiele zum Speichern und Laden von Modellen: http://machinelearningmastery.com/save-load-keras-deep-learning-models/https: // github. de/fchollet/keras/fragen/1872

Aber keiner von ihnen funktioniert. Kann mir jemand helfen? Vielen Dank.

Update

Ein trainiertes Keras-Modell laden und das Training fortsetzen

Ich habe es versucht 

model.save('partly_trained.h5')
del model
load_model('partly_trained.h5')

es klappt. Aber wenn ich Python geschlossen habe, öffne und load_model erneut. Es schlägt fehl. Der Verlust ist so hoch wie im Ausgangszustand.

Update

Ich habe Yu-Yangs Beispielcode ausprobiert. Es klappt. Aber zurück zu meinem Code habe ich immer noch versagt .. Dies ist das ursprüngliche Training. Die zweite Epoche sollte mit einem Verlust von 3,1 beginnen. 

13700/13846 [============================>.] - ETA: 0s - loss: 3.0519
13750/13846 [============================>.] - ETA: 0s - loss: 3.0511
13800/13846 [============================>.] - ETA: 0s - loss: 3.0512Epoch 00000: loss improved from inf to 3.05101, saving model to LPT-00-3.0510.h5

13846/13846 [==============================] - 81s - loss: 3.0510    
Epoch 2/60

   50/13846 [..............................] - ETA: 80s - loss: 3.1754
  100/13846 [..............................] - ETA: 78s - loss: 3.1174
  150/13846 [..............................] - ETA: 78s - loss: 3.0745

Ich habe Python geschlossen und es wieder geöffnet. Geladenes Modell mit model = load_model("LPT-00-3.0510.h5"), dann trainieren Sie mit 

filepath="LPT-{Epoch:02d}-{loss:.4f}.h5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# fit the model
model.fit(x, y, epochs=60, batch_size=50, callbacks=callbacks_list)

Der Verlust beginnt mit 4,54.

Epoch 1/60
   50/13846 [..............................] - ETA: 162s - loss: 4.5451
   100/13846 [..............................] - ETA: 113s - loss: 4.3835
13
David

Da es ziemlich schwierig ist zu klären, wo das Problem liegt, habe ich aus Ihrem Code ein Spielzeugbeispiel erstellt, und es scheint gut zu funktionieren.

import numpy as np
from numpy.testing import assert_allclose
from keras.models import Sequential, load_model
from keras.layers import LSTM, Dropout, Dense
from keras.callbacks import ModelCheckpoint

vec_size = 100
n_units = 10

x_train = np.random.Rand(500, 10, vec_size)
y_train = np.random.Rand(500, vec_size)

model = Sequential()
model.add(LSTM(n_units, input_shape=(None, vec_size), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units, return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(n_units))
model.add(Dropout(0.2))
model.add(Dense(vec_size, activation='linear'))
model.compile(loss='mean_squared_error', optimizer='adam')

# define the checkpoint
filepath = "model.h5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]

# fit the model
model.fit(x_train, y_train, epochs=5, batch_size=50, callbacks=callbacks_list)

# load the model
new_model = load_model("model.h5")
assert_allclose(model.predict(x_train),
                new_model.predict(x_train),
                1e-5)

# fit the model
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
new_model.fit(x_train, y_train, epochs=5, batch_size=50, callbacks=callbacks_list)

Der Verlust nimmt nach dem Laden des Modells weiter ab. (Der Neustart von Python ist auch kein Problem)

Using TensorFlow backend.
Epoch 1/5
500/500 [==============================] - 2s - loss: 0.3216     Epoch 00000: loss improved from inf to 0.32163, saving model to model.h5
Epoch 2/5
500/500 [==============================] - 0s - loss: 0.2923     Epoch 00001: loss improved from 0.32163 to 0.29234, saving model to model.h5
Epoch 3/5
500/500 [==============================] - 0s - loss: 0.2542     Epoch 00002: loss improved from 0.29234 to 0.25415, saving model to model.h5
Epoch 4/5
500/500 [==============================] - 0s - loss: 0.2086     Epoch 00003: loss improved from 0.25415 to 0.20860, saving model to model.h5
Epoch 5/5
500/500 [==============================] - 0s - loss: 0.1725     Epoch 00004: loss improved from 0.20860 to 0.17249, saving model to model.h5

Epoch 1/5
500/500 [==============================] - 0s - loss: 0.1454     Epoch 00000: loss improved from inf to 0.14543, saving model to model.h5
Epoch 2/5
500/500 [==============================] - 0s - loss: 0.1289     Epoch 00001: loss improved from 0.14543 to 0.12892, saving model to model.h5
Epoch 3/5
500/500 [==============================] - 0s - loss: 0.1169     Epoch 00002: loss improved from 0.12892 to 0.11694, saving model to model.h5
Epoch 4/5
500/500 [==============================] - 0s - loss: 0.1097     Epoch 00003: loss improved from 0.11694 to 0.10971, saving model to model.h5
Epoch 5/5
500/500 [==============================] - 0s - loss: 0.1057     Epoch 00004: loss improved from 0.10971 to 0.10570, saving model to model.h5

Übrigens, das Neudefinieren des Modells gefolgt von load_weight() wird definitiv nicht funktionieren, da save_weight() und load_weight() das Optimierungsprogramm nicht speichern/laden.

14
Yu-Yang

Ich verglich meinen Code mit diesem Beispiel http://machinelearningmastery.com/text-generation-lstm-recurrent-neural-networks-python-keras/ , Indem ich Zeile für Zeile sorgfältig ausblocken und erneut ausführen . Nach einem ganzen Tag fand ich endlich heraus, was falsch war.

Bei der Erstellung von Char-Int-Mapping habe ich verwendet 

# title_str_reduced is a string
chars = list(set(title_str_reduced))
# make char to int index mapping
char2int = {}
for i in range(len(chars)):
    char2int[chars[i]] = i    

Ein Satz ist eine ungeordnete Datenstruktur. Wenn in Python eine Menge in eine geordnete Liste umgewandelt wird, wird die Reihenfolge zufällig vergeben. Daher wird mein char2int-Wörterbuch jedes Mal zufällig ausgewählt, wenn ich Python wieder öffne. Ich habe meinen Code durch Hinzufügen eines sortierten () korrigiert.

chars = sorted(list(set(title_str_reduced)))

Dies zwingt die Konvertierung zu einer festen Reihenfolge. 

1
David

Hier ist die offizielle Kera-Dokumentation zum Speichern eines Modells:

https://keras.io/getting-started/faq/#how-can-i-save-a-keras-model

In diesem Beitrag bietet der Autor zwei Beispiele zum Speichern und Laden Ihres Modells als Datei an:

  • JSON-Format. 
  • YAML foramt.
0
Anubhav Apurva

angenommen, Sie haben einen Code wie diesen:

model = some_model_you_made(input_img) # you compiled your model in this 
model.summary()

model_checkpoint = ModelCheckpoint('yours.h5', monitor='val_loss', verbose=1, save_best_only=True)

model_json = model.to_json()
with open("yours.json", "w") as json_file:
    json_file.write(model_json)

model.fit_generator(#stuff...) # or model.fit(#stuff...)

Verwandeln Sie nun Ihren Code in Folgendes:

model = some_model_you_made(input_img) #same model here
model.summary()

model_checkpoint = ModelCheckpoint('yours.h5', monitor='val_loss', verbose=1, save_best_only=True) #same ckeckpoint

model_json = model.to_json()
with open("yours.json", "w") as json_file:
    json_file.write(model_json)

with open('yours.json', 'r') as f:
    old_model = model_from_json(f.read()) # open the model you just saved (same as your last train) with a different name

old_model.load_weights('yours.h5') # the model checkpoint you trained before
old_model.compile(#stuff...) # need to compile again (exactly like the last compile)

# now start training with the checkpoint...
old_model.fit_generator(#same stuff like the last train) # or model.fit(#stuff...)
0
Meisam

Ich denke du kannst schreiben

model.save('partly_trained.h5' )

und

model = load_model('partly_trained.h5'),

anstatt von

model = Sequential()model.add(LSTM(n_units, input_shape=(None, vec_size), return_sequences=True))model.add(Dropout(0.2))model.add(LSTM(n_units, return_sequences=True))model.add(Dropout(0.2))model.add(LSTM(n_units))model.add(Dropout(0.2))model.add(Dense(vec_size, activation='linear'))model.compile(loss='mean_squared_error', optimizer='adam'),

Dann mach weiter mit dem Training. Weil model.save sowohl Architektur als auch Gewichte speichert.

0
bruce