def test_fuctional_model_saving():
input = Input(shape=(3,))
x = Dense(2)(input)
output = Dense(3)(x)
model = Model(input, output)
model.compile(loss=objectives.MSE,
optimizer=optimizers.RMSprop(lr=0.0001),
metrics=[metrics.categorical_accuracy])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp('.h5')
save_model(model, fname)
model = load_model(fname)
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
python类RMSprop()的实例源码
def test_saving_lambda_custom_objects():
input = Input(shape=(3,))
x = Lambda(lambda x: square_fn(x), output_shape=(3,))(input)
output = Dense(3)(x)
model = Model(input, output)
model.compile(loss=objectives.MSE,
optimizer=optimizers.RMSprop(lr=0.0001),
metrics=[metrics.categorical_accuracy])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp('.h5')
save_model(model, fname)
model = load_model(fname, custom_objects={'square_fn': square_fn})
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
def _init_MLP(self, mlp_layers):
"""Initialize the MLP that corresponds to the Q function.
Parameters
----------
state_dim : The state dimensionality
nb_actions : The number of possible actions
mlp_layers : A list consisting of an integer number of neurons for each
hidden layer. Default = [20, 20]
"""
model = Sequential()
for i in range(len(mlp_layers)):
if i == 0:
model.add(Dense(mlp_layers[i],
input_dim=self.state_dim + self.nb_actions))
else:
model.add(Dense(mlp_layers[i]))
model.add(Activation('relu'))
model.add(Dense(1))
model.add(Activation('relu'))
rmsprop = RMSprop()
model.compile(loss='mean_squared_error', optimizer=rmsprop)
return model
def make_discriminator(self):
# TODO just to have something, 5 layers vgg-like
inputs = Input(shape=self.img_shape)
enc1 = self.downsampling_block_basic(inputs, 64, 7)
enc2 = self.downsampling_block_basic(enc1, 64, 7)
enc3 = self.downsampling_block_basic(enc2, 92, 7)
enc4 = self.downsampling_block_basic(enc3, 128, 7)
enc5 = self.downsampling_block_basic(enc4, 128, 7)
flat = Flatten()(enc5)
dense1 = Dense(512, activation='sigmoid')(flat)
dense2 = Dense(512, activation='sigmoid')(dense1)
fake = Dense(1, activation='sigmoid', name='generation')(dense2)
# Dense(2,... two classes : real and fake
# change last activation to softmax ?
discriminator = kmodels.Model(input=inputs, output=fake)
lr = 1e-04
optimizer = RMSprop(lr=lr, rho=0.9, epsilon=1e-8, clipnorm=10)
print (' Optimizer discriminator: rmsprop. Lr: {}. Rho: 0.9, epsilon=1e-8, '
'clipnorm=10'.format(lr))
discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)
# TODO metrics=metrics,
return discriminator
def build_functions(self):
S = Input(shape=self.state_size)
NS = Input(shape=self.state_size)
A = Input(shape=(1,), dtype='int32')
R = Input(shape=(1,), dtype='float32')
T = Input(shape=(1,), dtype='int32')
self.build_model()
self.value_fn = K.function([S], self.model(S))
VS = self.model(S)
VNS = disconnected_grad(self.model(NS))
future_value = (1-T) * VNS.max(axis=1, keepdims=True)
discounted_future_value = self.discount * future_value
target = R + discounted_future_value
cost = ((VS[:, A] - target)**2).mean()
opt = RMSprop(0.0001)
params = self.model.trainable_weights
updates = opt.get_updates(params, [], cost)
self.train_fn = K.function([S, NS, A, R, T], cost, updates=updates)
def image_caption_model(vocab_size=2500, embedding_matrix=None, lang_dim=100,
max_caplen=28, img_dim=2048, clipnorm=1):
print('generating vocab_history model v5')
# text: current word
lang_input = Input(shape=(1,))
img_input = Input(shape=(img_dim,))
seq_input = Input(shape=(max_caplen,))
vhist_input = Input(shape=(vocab_size,))
if embedding_matrix is not None:
x = Embedding(output_dim=lang_dim, input_dim=vocab_size, init='glorot_uniform', input_length=1, weights=[embedding_matrix])(lang_input)
else:
x = Embedding(output_dim=lang_dim, input_dim=vocab_size, init='glorot_uniform', input_length=1)(lang_input)
lang_embed = Reshape((lang_dim,))(x)
lang_embed = merge([lang_embed, seq_input], mode='concat', concat_axis=-1)
lang_embed = Dense(lang_dim)(lang_embed)
lang_embed = Dropout(0.25)(lang_embed)
merge_layer = merge([img_input, lang_embed, vhist_input], mode='concat', concat_axis=-1)
merge_layer = Reshape((1, lang_dim+img_dim+vocab_size))(merge_layer)
gru_1 = GRU(img_dim)(merge_layer)
gru_1 = Dropout(0.25)(gru_1)
gru_1 = Dense(img_dim)(gru_1)
gru_1 = BatchNormalization()(gru_1)
gru_1 = Activation('softmax')(gru_1)
attention_1 = merge([img_input, gru_1], mode='mul', concat_axis=-1)
attention_1 = merge([attention_1, lang_embed, vhist_input], mode='concat', concat_axis=-1)
attention_1 = Reshape((1, lang_dim + img_dim + vocab_size))(attention_1)
gru_2 = GRU(1024)(attention_1)
gru_2 = Dropout(0.25)(gru_2)
gru_2 = Dense(vocab_size)(gru_2)
gru_2 = BatchNormalization()(gru_2)
out = Activation('softmax')(gru_2)
model = Model(input=[img_input, lang_input, seq_input, vhist_input], output=out)
model.compile(loss='categorical_crossentropy', optimizer=RMSprop(lr=0.0001, clipnorm=1.))
return model
def run_benchmark(self, gpus=0):
input_dim_1 = 40
input_dim_2 = 60
input_shape = (self.num_samples, input_dim_1, 60)
x, y = generate_text_input_data(input_shape)
# build the model: a single LSTM
model = Sequential()
model.add(LSTM(128, input_shape=(input_dim_1, input_dim_2)))
model.add(Dense(input_dim_2), activation='softmax')
optimizer = RMSprop(lr=0.01)
if keras.backend.backend() is "tensorflow" and gpus > 1:
model = multi_gpu_model(model, gpus=gpus)
model.compile(loss='categorical_crossentropy', optimizer=optimizer)
# create a distributed trainer for cntk
if keras.backend.backend() is "cntk" and gpus > 1:
start, end = cntk_gpu_mode_config(model, x.shape[0])
x = x[start: end]
y = y[start: end]
time_callback = timehistory.TimeHistory()
model.fit(x, y,
batch_size=self.batch_size,
epochs=self.epochs,
callbacks=[time_callback])
self.total_time = 0
for i in range(1, self.epochs):
self.total_time += time_callback.times[i]
def run_benchmark(self, gpus=0):
num_classes = 10
# Generate random input data
input_shape = (self.num_samples, 28, 28)
x_train, y_train = generate_img_input_data(input_shape)
x_train = x_train.reshape(self.num_samples, 784)
x_train = x_train.astype('float32')
x_train /= 255
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes, activation='softmax'))
if keras.backend.backend() is "tensorflow" and gpus > 1:
model = multi_gpu_model(model, gpus=gpus)
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
# create a distributed trainer for cntk
if keras.backend.backend() is "cntk" and gpus > 1:
start, end = cntk_gpu_mode_config(model, x_train.shape[0])
x_train = x_train[start: end]
y_train = y_train[start: end]
time_callback = timehistory.TimeHistory()
model.fit(x_train, y_train, batch_size=self.batch_size,
epochs=self.epochs, verbose=1, callbacks=[time_callback])
self.total_time = 0
for i in range(1, self.epochs):
self.total_time += time_callback.times[i]
def init_model_1():
start_time = time.time()
print 'Compiling model...'
model = Sequential()
model.add(Convolution2D(64, 3,3, border_mode='valid',input_shape=INPUT_SHAPE))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3,3, border_mode='valid'))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(.5))
model.add(Dense(10))
model.add(Activation('softmax'))
rms = RMSprop()
model.compile(loss='categorical_crossentropy', optimizer=rms,
metrics=['accuracy'])
print 'Model compiled in {0} seconds'.format(time.time() - start_time)
return model
def __init__(self, data_dir, model_filename, weights_filename, categories_filename, history_filename, train_test_split_percentage, num_training_epochs, verbose):
self.sample_size = 64 # input image size (will rescale data to this size)
self.optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08)
self.train_test_split_percentage = train_test_split_percentage
self.data_dir = data_dir
self.model_filename = model_filename
self.weights_filename = weights_filename
self.categories_filename = categories_filename
self.history_filename = history_filename
self.num_training_epochs = num_training_epochs
self.verbose = verbose
def __init__(self, data_dir, model_architecture, model_filename, weights_filename, categories_filename, history_filename, train_test_split_percentage, num_training_epochs, verbose):
self.sample_size = 224 # this needs to match the input size of the pre-trained network, or you need to remove the input layer from the current network and replace it with the input size you would like
self.optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08)
self.train_test_split_percentage = train_test_split_percentage
self.data_dir = data_dir
self.model_architecture = model_architecture
self.model_filename = model_filename
self.weights_filename = weights_filename
self.categories_filename = categories_filename
self.history_filename = history_filename
self.num_training_epochs = num_training_epochs
self.verbose = verbose
def test_rmsprop():
_test_optimizer(RMSprop())
_test_optimizer(RMSprop(decay=1e-3))
def test_sequential_model_saving():
model = Sequential()
model.add(Dense(2, input_dim=3))
model.add(RepeatVector(3))
model.add(TimeDistributed(Dense(3)))
model.compile(loss=objectives.MSE,
optimizer=optimizers.RMSprop(lr=0.0001),
metrics=[metrics.categorical_accuracy],
sample_weight_mode='temporal')
x = np.random.random((1, 3))
y = np.random.random((1, 3, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp('.h5')
save_model(model, fname)
new_model = load_model(fname)
os.remove(fname)
out2 = new_model.predict(x)
assert_allclose(out, out2, atol=1e-05)
# test that new updates are the same with both models
x = np.random.random((1, 3))
y = np.random.random((1, 3, 3))
model.train_on_batch(x, y)
new_model.train_on_batch(x, y)
out = model.predict(x)
out2 = new_model.predict(x)
assert_allclose(out, out2, atol=1e-05)
def _compile(self):
""" compile self.q_vals
"""
if (self._update_rule=="sgd"):
optimizer = SGD(lr=self._lr, momentum=self._momentum, nesterov=False)
elif (self._update_rule=="rmsprop"):
optimizer = RMSprop(lr=self._lr, rho=self._rho, epsilon=self._rms_epsilon)
else:
raise Exception('The update_rule '+self._update_rule+' is not implemented.')
self.q_vals.compile(optimizer=optimizer, loss='mse')
def build_stateful_lstm_model(batch_size,time_step,input_dim,output_dim,dropout=0.2,rnn_layer_num=2,hidden_dim=128,hidden_num=0,rnn_type='LSTM'):
model = Sequential()
# may use BN for accelerating speed
# add first LSTM
if rnn_type == 'LSTM':
rnn_cell = LSTM
elif rnn_type == 'GRU':
rnn_cell = GRU
elif rnn_type == 'SimpleRNN':
rnn_cell = SimpleRNN
else:
raise ValueError('Option rnn_type could only be configured as LSTM, GRU or SimpleRNN')
model.add(rnn_cell(hidden_dim,return_sequences=True,batch_input_shape=(batch_size,time_step,input_dim)))
for _ in range(rnn_layer_num-2):
model.add(rnn_cell(hidden_dim, return_sequence=True))
# prevent over fitting
model.add(Dropout(dropout))
model.add(rnn_cell(hidden_dim,return_sequences=False))
# add hidden layer
for _ in range(hidden_num):
model.add(Dense(hidden_dim))
model.add(Dropout(dropout))
model.add(Dense(output_dim))
rmsprop = RMSprop(lr=0.01)
adam = Adam(lr=0.01)
model.compile(loss='mse',metrics=['acc'],optimizer=rmsprop)
return model
def discriminator_model(self):
if self.DM:
return self.DM
optimizer = RMSprop(lr=0.0002, decay=6e-8)
self.DM = Sequential()
self.DM.add(self.discriminator())
self.DM.compile(loss='binary_crossentropy', optimizer=optimizer,\
metrics=['accuracy'])
return self.DM
def adversarial_model(self):
if self.AM:
return self.AM
optimizer = RMSprop(lr=0.0001, decay=3e-8)
self.AM = Sequential()
self.AM.add(self.generator())
self.AM.add(self.discriminator())
self.AM.compile(loss='binary_crossentropy', optimizer=optimizer,\
metrics=['accuracy'])
return self.AM
def model(X_train, Y_train, X_test, Y_test):
'''
Model providing function:
Create Keras model with double curly brackets dropped-in as needed.
Return value has to be a valid python dictionary with two customary keys:
- loss: Specify a numeric evaluation metric to be minimized
- status: Just use STATUS_OK and see hyperopt documentation if not feasible
The last one is optional, though recommended, namely:
- model: specify the model just created so that we can later use it again.
'''
model = Sequential()
model.add(Dense(512, input_shape=(784,)))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense({{choice([256, 512, 1024])}}))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(10))
model.add(Activation('softmax'))
rms = RMSprop()
model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy'])
model.fit(X_train, Y_train,
batch_size={{choice([64, 128])}},
nb_epoch=1,
verbose=2,
validation_data=(X_test, Y_test))
score, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test accuracy:', acc)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def model(X_train, Y_train, X_test, Y_test):
'''
Model providing function:
Create Keras model with double curly brackets dropped-in as needed.
Return value has to be a valid python dictionary with two customary keys:
- loss: Specify a numeric evaluation metric to be minimized
- status: Just use STATUS_OK and see hyperopt documentation if not feasible
The last one is optional, though recommended, namely:
- model: specify the model just created so that we can later use it again.
'''
model = Sequential()
model.add(Dense(512, input_shape=(784,)))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense({{choice([256, 512, 1024])}}))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(10))
model.add(Activation('softmax'))
rms = RMSprop()
model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy'])
model.fit(X_train, Y_train,
batch_size={{choice([64, 128])}},
nb_epoch=1,
verbose=2,
validation_data=(X_test, Y_test))
score, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test accuracy:', acc)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def get_learning_rate(self):
if hasattr(self.model, 'optimizer'):
config = self.model.optimizer.get_config()
from keras.optimizers import Adadelta, Adam, Adamax, Adagrad, RMSprop, SGD
if isinstance(self.model.optimizer, Adadelta) or isinstance(self.model.optimizer, Adam) \
or isinstance(self.model.optimizer, Adamax) or isinstance(self.model.optimizer, Adagrad)\
or isinstance(self.model.optimizer, RMSprop) or isinstance(self.model.optimizer, SGD):
return config['lr'] * (1. / (1. + config['decay'] * float(K.get_value(self.model.optimizer.iterations))))
elif 'lr' in config:
return config['lr']
def test_sequential_model_saving_2():
# test with custom optimizer, loss
custom_opt = optimizers.rmsprop
custom_loss = objectives.mse
model = Sequential()
model.add(Dense(2, input_dim=3))
model.add(Dense(3))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp('.h5')
save_model(model, fname)
model = load_model(fname,
custom_objects={'custom_opt': custom_opt,
'custom_loss': custom_loss})
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
def test_sequential_model_saving_2():
# test with custom optimizer, loss
custom_opt = optimizers.rmsprop
custom_loss = objectives.mse
model = Sequential()
model.add(Dense(2, input_dim=3))
model.add(Dense(3))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp('.h5')
save_model(model, fname)
model = load_model(fname,
custom_objects={'custom_opt': custom_opt,
'custom_loss': custom_loss})
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
def test_sequential_model_saving_2():
# test with custom optimizer, loss
custom_opt = optimizers.rmsprop
custom_loss = objectives.mse
model = Sequential()
model.add(Dense(2, input_dim=3))
model.add(Dense(3))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
_, fname = tempfile.mkstemp('.h5')
save_model(model, fname)
model = load_model(fname,
custom_objects={'custom_opt': custom_opt,
'custom_loss': custom_loss})
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
def _initialize_model(self):
input_layer = Input(shape=self.input_shape)
tower_1 = Convolution2D(16, 1, 1, border_mode="same", activation="elu")(input_layer)
tower_1 = Convolution2D(16, 3, 3, border_mode="same", activation="elu")(tower_1)
tower_2 = Convolution2D(16, 1, 1, border_mode="same", activation="elu")(input_layer)
tower_2 = Convolution2D(16, 3, 3, border_mode="same", activation="elu")(tower_2)
tower_2 = Convolution2D(16, 3, 3, border_mode="same", activation="elu")(tower_2)
tower_3 = MaxPooling2D((3, 3), strides=(1, 1), border_mode="same")(input_layer)
tower_3 = Convolution2D(16, 1, 1, border_mode="same", activation="elu")(tower_3)
merged_layer = merge([tower_1, tower_2, tower_3], mode="concat", concat_axis=1)
output = AveragePooling2D((7, 7), strides=(8, 8))(merged_layer)
output = Flatten()(output)
output = Dense(self.action_count)(output)
model = Model(input=input_layer, output=output)
model.compile(rmsprop(lr=self.model_learning_rate, clipvalue=1), "mse")
return model
def get_optimizer(config):
if(config['optimizer'] == 'rmsprop'):
opti = optimizers.rmsprop(lr=config['learning_rate'],
clipvalue=config['grad_clip'],
decay=config['decay_rate'])
return opti
elif(config['optimizer'] == 'adadelta'):
opti = optimizers.adadelta(lr=config['learning_rate'],
clipvalue=config['grad_clip'])
return opti
elif(config['optimizer'] == 'sgd'):
opti = optimizers.sgd(lr=config['learning_rate'],
momentum=config['momentum'],
decay=config['learning_rate_decay'])
return opti
else:
raise StandardError('optimizer name error')
def compile_model(self):
self.model.compile(loss=losses.mean_squared_error,
optimizer=optimizers.rmsprop(),
metrics=['accuracy'])
def compile_model(self):
self.model.compile(loss=losses.categorical_crossentropy,
optimizer=optimizers.rmsprop(),
metrics=['accuracy'])
self.graph = tf.get_default_graph()
def test_loading_weights_by_name():
"""
test loading model weights by name on:
- sequential model
"""
# test with custom optimizer, loss
custom_opt = optimizers.rmsprop
custom_loss = objectives.mse
# sequential model
model = Sequential()
model.add(Dense(2, input_dim=3, name="rick"))
model.add(Dense(3, name="morty"))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
old_weights = [layer.get_weights() for layer in model.layers]
_, fname = tempfile.mkstemp('.h5')
model.save_weights(fname)
# delete and recreate model
del(model)
model = Sequential()
model.add(Dense(2, input_dim=3, name="rick"))
model.add(Dense(3, name="morty"))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
# load weights from first model
model.load_weights(fname, by_name=True)
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
for i in range(len(model.layers)):
new_weights = model.layers[i].get_weights()
for j in range(len(new_weights)):
assert_allclose(old_weights[i][j], new_weights[j], atol=1e-05)
def test_loading_weights_by_name_2():
"""
test loading model weights by name on:
- both sequential and functional api models
- different architecture with shared names
"""
# test with custom optimizer, loss
custom_opt = optimizers.rmsprop
custom_loss = objectives.mse
# sequential model
model = Sequential()
model.add(Dense(2, input_dim=3, name="rick"))
model.add(Dense(3, name="morty"))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
old_weights = [layer.get_weights() for layer in model.layers]
_, fname = tempfile.mkstemp('.h5')
model.save_weights(fname)
# delete and recreate model using Functional API
del(model)
data = Input(shape=(3,))
rick = Dense(2, name="rick")(data)
jerry = Dense(3, name="jerry")(rick) # add 2 layers (but maintain shapes)
jessica = Dense(2, name="jessica")(jerry)
morty = Dense(3, name="morty")(jessica)
model = Model(input=[data], output=[morty])
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
# load weights from first model
model.load_weights(fname, by_name=True)
os.remove(fname)
out2 = model.predict(x)
assert np.max(np.abs(out - out2)) > 1e-05
rick = model.layers[1].get_weights()
jerry = model.layers[2].get_weights()
jessica = model.layers[3].get_weights()
morty = model.layers[4].get_weights()
assert_allclose(old_weights[0][0], rick[0], atol=1e-05)
assert_allclose(old_weights[0][1], rick[1], atol=1e-05)
assert_allclose(old_weights[1][0], morty[0], atol=1e-05)
assert_allclose(old_weights[1][1], morty[1], atol=1e-05)
assert_allclose(np.zeros_like(jerry[1]), jerry[1]) # biases init to 0
assert_allclose(np.zeros_like(jessica[1]), jessica[1]) # biases init to 0
def test_loading_weights_by_name():
"""
test loading model weights by name on:
- sequential model
"""
# test with custom optimizer, loss
custom_opt = optimizers.rmsprop
custom_loss = objectives.mse
# sequential model
model = Sequential()
model.add(Dense(2, input_dim=3, name="rick"))
model.add(Dense(3, name="morty"))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
x = np.random.random((1, 3))
y = np.random.random((1, 3))
model.train_on_batch(x, y)
out = model.predict(x)
old_weights = [layer.get_weights() for layer in model.layers]
_, fname = tempfile.mkstemp('.h5')
model.save_weights(fname)
# delete and recreate model
del(model)
model = Sequential()
model.add(Dense(2, input_dim=3, name="rick"))
model.add(Dense(3, name="morty"))
model.compile(loss=custom_loss, optimizer=custom_opt(), metrics=['acc'])
# load weights from first model
model.load_weights(fname, by_name=True)
os.remove(fname)
out2 = model.predict(x)
assert_allclose(out, out2, atol=1e-05)
for i in range(len(model.layers)):
new_weights = model.layers[i].get_weights()
for j in range(len(new_weights)):
assert_allclose(old_weights[i][j], new_weights[j], atol=1e-05)
