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
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.
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.
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:
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...)
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.