def on_epoch_end(self, epoch, logs=None):
EMAer.apply_ema_weights()
acc, f1, final = self.evaluate()
self.metrics.append((epoch, acc, f1, final))
json.dump(self.metrics, open('train.log', 'w'), indent=4)
if final > self.best:
self.best = final
train_model.save_weights('best_model.weights')
print('learning rate: %s' % (K.eval(self.model.optimizer.lr)))
print('acc: %.4f, f1: %.4f, final: %.4f, best final: %.4f\n' %
(acc, f1, final, self.best))
EMAer.reset_old_weights()
if epoch + 1 == 30 or (self.stage == 0 and epoch > 15 and
(final < 0.5 or np.argmax(self.metrics, 0)[3] <
len(self.metrics) - 5)):
"""达到30个epoch，或者final开始下降到0.5以下（开始发散），
或者连续5个epoch都没提升，就降低学习率。
"""
self.stage = 1
train_model.load_weights('best_model.weights')
EMAer.initialize()
K.set_value(self.model.optimizer.lr, 1e-4)
K.set_value(self.model.optimizer.iterations, 0)
opt_weights = K.batch_get_value(self.model.optimizer.weights)
opt_weights = [w * 0. for w in opt_weights]
K.batch_set_value(zip(self.model.optimizer.weights, opt_weights))
def load_weights(model, filepath):
flattened_layers = model.layers
with h5py.File(filepath, mode='r') as f:
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for name in layer_names:
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [
g[weight_name] for weight_name in weight_names
]
try:
layer = model.get_layer(name=name)
except:
layer = None
if not layer:
weight_values = [np.array(w) for w in weight_values]
break
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
weight_value_tuples += zip(symbolic_weights, weight_values)
weight_values = None
K.batch_set_value(weight_value_tuples)
return weight_values
def _transfer_weights(to_model, from_model):
to_layers = to_model.inner_model.layers \
if hasattr(to_model, "inner_model") \
else to_model.layers
from_layers = from_model.inner_model.layers \
if hasattr(from_model, "inner_model") \
else from_model.layers
from_index = {}
for from_layer in from_layers:
if from_layer.name:
from_index.setdefault(from_layer.name, []).append(from_layer)
# We batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for to_layer in to_layers:
name = to_layer.name
for from_layer in from_index.get(name, []):
to_weights = to_layer.weights
from_weights = from_layer.get_weights()
if len(to_weights) != len(from_weights):
raise ValueError(
'Target layer %s expects %d weight(s), '
'but the source layer have %d element(s)' %
(name, len(to_weights), len(from_weights)))
print('%d Weights in Layer %s is transfered' %
(len(to_weights), name))
for to_w, from_w in zip(to_weights, from_weights):
weight_value_tuples.append((to_w, from_w))
K.batch_set_value(weight_value_tuples)
def set_weights(self, weights):
"""Sets the weights of the optimizer, from Numpy arrays.
Should only be called after computing the gradients
(otherwise the optimizer has no weights).
Arguments:
weights: a list of Numpy arrays. The number of arrays and their shape
must match number of the dimensions of the weights of the optimizer
(i.e. it should match the output of `get_weights`).
Raises:
ValueError: in case of incompatible weight shapes.
"""
params = self.weights
if len(params) != len(weights):
raise ValueError('Length of the specified weight list (' +
str(len(weights)) +
') does not match the number of weights '
'of the optimizer (' + str(len(params)) + ')')
weight_value_tuples = []
param_values = K.batch_get_value(params)
for pv, p, w in zip(param_values, params, weights):
if pv.shape != w.shape:
raise ValueError('Optimizer weight shape ' + str(pv.shape) +
' not compatible with '
'provided weight shape ' + str(w.shape))
weight_value_tuples.append((p, w))
K.batch_set_value(weight_value_tuples)
def on_epoch_end(self, epoch, logs={}):
if epoch % self.freq == 0:
response = [self._model.predict(self.x_data)]
K.batch_set_value(list(zip(self.tensor, response)))
self.saver.save(self.sess,
os.path.join(self.log_dir, 'keras_embedding.ckpt'),
epoch)
def load_weights_by_name(model, path, reshape=False):
f = h5py.File(path, 'r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
layers = model.layers
if 'keras_version' in f.attrs:
original_keras_version = f.attrs['keras_version'].decode('utf8')
else:
original_keras_version = '1'
if 'backend' in f.attrs:
original_backend = f.attrs['backend'].decode('utf8')
else:
original_backend = None
layer_names = load_attributes_from_hdf5_group(f, 'layer_names')
weights_dict = {}
for k, name in enumerate(layer_names):
g = f[name]
weight_names = load_attributes_from_hdf5_group(g, 'weight_names')
[
weights_dict.update({weight_name: np.asarray(g[weight_name])})
for weight_name in weight_names
]
weight_value_tuples = []
for layer in layers:
load_weights(weights_dict,
layer,
weight_value_tuples,
original_keras_version,
original_backend,
reshape=reshape)
K.batch_set_value(weight_value_tuples)
def save_bottleneck_features():
model = Sequential()
model.add(Convolution2D(32, 3, 3, input_shape=(1, img_width, img_height)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.1))
model.add(Convolution2D(64, 2, 2))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Convolution2D(128, 2, 2))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.3))
assert os.path.exists(weights_path), 'Model weights not found (see "weights_path" variable in script).'
f = h5py.File(weights_path)
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
weight_value_tuples = []
for k, name in enumerate(layer_names):
if k >= len(model.layers):
break
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
layer = model.layers[k]
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
f.close()
print('Model loaded.')
X, y = load2d()
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
X_flipped, y_flipped = flip_image(X_train, y_train)
X_train = np.vstack((X_train, X_flipped))
y_train = np.vstack((y_train, y_flipped))
bottleneck_features_train = model.predict(X_train)
np.save(open('bottleneck_features_train.npy', 'w'), bottleneck_features_train)
np.save(open('label_train.npy', 'w'), y_train)
bottleneck_features_validation = model.predict(X_val)
np.save(open('bottleneck_features_validation.npy', 'w'), bottleneck_features_validation)
np.save(open('label_validation.npy', 'w'), y_val)
def load_weights(model, filepath):
"""Modified version of keras load_weights that loads as much as it can
if there is a mismatch between file and model. It returns the weights
of the first layer in which the mismatch has happened
"""
flattened_layers = model.layers
with h5py.File(filepath, mode='r') as f:
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
weight_value_tuples = []
for name in layer_names:
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
try:
layer = model.get_layer(name=name)
except:
layer = None
if not layer:
weight_values = [np.array(w) for w in weight_values]
break
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
weight_value_tuples += zip(symbolic_weights, weight_values)
weight_values = None
K.batch_set_value(weight_value_tuples)
return weight_values
def load_weights_from_hdf5_group_by_weights_name(f,
weights,
weight_name_map={},
verbose=False):
''' f: a hdf5 group of weights.
weights: weights in the current graph to be assigned.
weight_name_map: {key: value} == {weight name in current graph: corresponding weight name in f
verbose: if True, print weight value tuples before assigning.
'''
weight_value_tuples = []
for w in weights:
try:
if w.name in weight_name_map:
match_weight_name = weight_name_map[w.name]
else:
match_weight_name = w.name
weight_value_tuples.append((w, f[match_weight_name]))
except:
print('Error!')
print(w, w.name, match_weight_name)
if verbose:
print('Weight value tuples:')
from pprint import pprint
pprint(weight_value_tuples)
K.batch_set_value(weight_value_tuples)
def load_weights_by_name(f, layers):
"""Load the weights by name from the h5py file to the model"""
# If f is not an h5py thing try to open it
if not isinstance(f, (h5py.File, h5py.Group)):
with h5py.File(f, "r") as h5f:
return load_weights_by_name(h5f, layers)
# Extract all the weights from the layers/model
if not isinstance(layers, list):
layers = layers.layers
weights = dict(
reduce(lambda a, x: a + [(w.name, w) for w in x.weights], layers, []))
# Loop through all the possible layer weights in the file and make a list
# of updates
updates = []
updated = []
for name, weight in weights_from_hdf5(f):
for n in possible_weight_names(name):
if n in weights:
updates.append((weights[n], weight))
updated.append(n)
break
K.batch_set_value(updates)
return updated
def get_weights_from_h5_group(model, model_weights, verbose=1):
layers = model.layers
weight_value_tuples = []
for layer in layers:
name = layer.name
if name in model_weights and len(model_weights[name]) > 0:
layer_weights = model_weights[name]
weight_names = [n.decode('utf8') for n in layer_weights.attrs['weight_names']]
weight_values = [layer_weights[weight_name] for weight_name in weight_names]
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
if verbose:
print('Setting_weights for layer:', name)
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def identity_initialize_temporal_layer(tlayer):
if not tlayer.weights:
print('no weights in %s' % tlayer.name)
return
kernel, bias = tlayer.weights
assert len(kernel.shape) == 5
assert len(bias.shape) == 1
k, _, _, fin, fout = map(int, tlayer.weights[0].shape)
assert k % 2 == 1, 'k must be odd number.'
assert fin == fout, \
''' input channel %d does not equal to output channel %d,
which makes it impossible to have identity weights. '''
bias_np = np.zeros(fout)
kernel_np = np.expand_dims(
np.expand_dims(np.expand_dims(np.eye(fout), 0), 0), 0)
# TODO: pad zeros
kernel_np = np.pad(kernel_np, (((k - 1) // 2, (k - 1) // 2), (0, 0),
(0, 0), (0, 0), (0, 0)),
'constant',
constant_values=0)
weight_value_tuples = [
(kernel, kernel_np),
(bias, bias_np),
]
K.batch_set_value(weight_value_tuples)
def test_load_layers():
from keras.layers import ConvLSTM2D, TimeDistributed, Bidirectional, Conv2D, Input
from keras.models import Model
if K.backend() == 'tensorflow' or K.backend() == 'cntk':
inputs = Input(shape=(10, 20, 20, 1))
else:
inputs = Input(shape=(10, 1, 20, 20))
td_conv = TimeDistributed(Conv2D(15, (5, 5)))(inputs)
bi_convlstm2d = Bidirectional(ConvLSTM2D(10, (3, 3)), merge_mode='concat')(td_conv)
model = Model(inputs=inputs, outputs=bi_convlstm2d)
weight_value_tuples = []
# TimeDistributed Conv2D layer
# use 'channels_first' data format to check that the function is being called correctly for Conv2D
# old: (filters, stack_size, kernel_rows, kernel_cols)
# new: (kernel_rows, kernel_cols, stack_size, filters)
weight_tensor_td_conv_old = list()
weight_tensor_td_conv_old.append(np.zeros((15, 1, 5, 5)))
weight_tensor_td_conv_old.append(np.zeros((15,)))
td_conv_layer = model.layers[1]
td_conv_layer.layer.data_format = 'channels_first'
weight_tensor_td_conv_new = topology.preprocess_weights_for_loading(
td_conv_layer,
weight_tensor_td_conv_old,
original_keras_version='1')
symbolic_weights = td_conv_layer.weights
assert (len(symbolic_weights) == len(weight_tensor_td_conv_new))
weight_value_tuples += zip(symbolic_weights, weight_tensor_td_conv_new)
# Bidirectional ConvLSTM2D layer
# old ConvLSTM2D took a list of 12 weight tensors, returns a list of 3 concatenated larger tensors.
weight_tensor_bi_convlstm_old = []
for j in range(2): # bidirectional
for i in range(4):
weight_tensor_bi_convlstm_old.append(np.zeros((3, 3, 15, 10))) # kernel
weight_tensor_bi_convlstm_old.append(np.zeros((3, 3, 10, 10))) # recurrent kernel
weight_tensor_bi_convlstm_old.append(np.zeros((10,))) # bias
bi_convlstm_layer = model.layers[2]
weight_tensor_bi_convlstm_new = topology.preprocess_weights_for_loading(
bi_convlstm_layer,
weight_tensor_bi_convlstm_old,
original_keras_version='1')
symbolic_weights = bi_convlstm_layer.weights
assert (len(symbolic_weights) == len(weight_tensor_bi_convlstm_new))
weight_value_tuples += zip(symbolic_weights, weight_tensor_bi_convlstm_new)
K.batch_set_value(weight_value_tuples)
assert np.all(K.eval(model.layers[1].weights[0]) == weight_tensor_td_conv_new[0])
assert np.all(K.eval(model.layers[1].weights[1]) == weight_tensor_td_conv_new[1])
assert np.all(K.eval(model.layers[2].weights[0]) == weight_tensor_bi_convlstm_new[0])
assert np.all(K.eval(model.layers[2].weights[1]) == weight_tensor_bi_convlstm_new[1])
assert np.all(K.eval(model.layers[2].weights[2]) == weight_tensor_bi_convlstm_new[2])
assert np.all(K.eval(model.layers[2].weights[3]) == weight_tensor_bi_convlstm_new[3])
assert np.all(K.eval(model.layers[2].weights[4]) == weight_tensor_bi_convlstm_new[4])
assert np.all(K.eval(model.layers[2].weights[5]) == weight_tensor_bi_convlstm_new[5])
def on_epoch_end(self, epoch, logs=None):
super(TensorResponseBoard, self).on_epoch_end(epoch, logs)
#super().on_epoch_end(epoch, logs)
print(self.xy.x_train)
print(self.embeddings.values())
if self.embeddings_freq and self.embeddings_ckpt_path:
if epoch % self.embeddings_freq == 0:
# feeding the validation data through the model
val_data = self.xy.x_train#self.validation_data[0]
print(self.xy.x_train)
print(self.embeddings.values())
#_encoded = model2.encoder.predict(input_encoder)[0]
#response_values = self.model.get_layer('decoder').get_layer(layer_name).output.get_value()#self.response_model.predict(val_data)
response_values=self.embeddings.values()
# record the response at each layers we're monitoring
response_tensors = []
for layer_name in self.embeddings_layer_names:
response_tensors.append(self.embeddings[layer_name])
K.batch_set_value(list(zip(response_tensors, response_values)))
# finally, save all tensors holding the layer responses
self.saver.save(self.sess, self.embeddings_ckpt_path, epoch)
def load_weights(model, weights_path):
"""Load weights from Caffe models."""
print("Loading weights...")
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
f = h5py.File(weights_path, mode='r')
# New file format.
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
# Reverse index of layer name to list of layers with name.
index = {}
for layer in model.layers:
if layer.name:
index.setdefault(layer.name, []).append(layer)
# We batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
weight_values = [g[weight_name] for weight_name in weight_names]
for layer in index.get(name, []):
symbolic_weights = layer.weights
# Set values.
for i in range(len(weight_values)):
weight_value_tuples.append(
(symbolic_weights[i], weight_values[i]))
K.batch_set_value(weight_value_tuples)
return layer_names
def load_weights(model, filepath):
"""Modified version of keras load_weights that loads as much as it can
if there is a mismatch between file and model. It returns the weights
of the first layer in which the mismatch has happened
"""
print 'Loading', filepath, 'to', model.name
flattened_layers = model.layers
with h5py.File(filepath, mode='r') as f:
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for name in layer_names:
print name
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
try:
layer = model.get_layer(name=name)
except:
layer = None
if not layer:
print 'failed to find layer', name, 'in model'
print 'weights', ' '.join(str_shape(w) for w in weight_values)
print 'stopping to load all other layers'
weight_values = [np.array(w) for w in weight_values]
break
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
weight_value_tuples += zip(symbolic_weights, weight_values)
weight_values = None
K.batch_set_value(weight_value_tuples)
return weight_values
def on_epoch_end(self, epoch, logs=None):
EMAer.apply_ema_weights()
f1, precision, recall = self.evaluate()
self.F1.append(f1)
if f1 > self.best:
self.best = f1
train_model.save_weights('./save/best_model.weights')
print('f1: %.4f, precision: %.4f, recall: %.4f, best f1: %.4f\n' %
(f1, precision, recall, self.best))
'''模型使用Adam优化器进行训练，先用10−3的学习率训练不超过50个epoch，
然后加载训练的最优结果，再用10−4的学习率继续训练到最优。
第一个epoch用来WarmUp，如果不进行WarmUp可能不收敛。
为了保证训练结果稳定提升，模型用到了EMA（Exponential Moving Average），衰减率为0.9999。
'''
EMAer.reset_old_weights()
if epoch + 1 == 50 or (self.stage == 0 and epoch > 10 and
(f1 < 0.5
or np.argmax(self.F1) < len(self.F1) - 8)):
self.stage = 1
train_model.load_weights('./save/best_model.weights')
EMAer.initialize()
K.set_value(self.model.optimizer.lr, learning_rate / 10)
K.set_value(self.model.optimizer.iterations, 0)
opt_weights = K.batch_get_value(self.model.optimizer.weights)
opt_weights = [w * 0. for w in opt_weights]
K.batch_set_value(zip(self.model.optimizer.weights, opt_weights))
def pop_art_update(self, x: np.ndarray) -> Tuple[float, float]:
"""
Performs ART (Adaptively Rescaling Targets) update,
adjusting normalization parameters with respect to new targets x.
Updates running mean, mean of squares and returns
new mean and standard deviation for later use.
"""
assert len(x.shape) == 2, "Must be 2D (batch_size, time_steps)"
beta = self.beta
(old_kernel, old_bias, old_online_mean, old_online_mean_of_square,
step, pop_is_active) = K.batch_get_value([
self.kernel, self.bias, self.mean, self.mean_of_square, self.step,
self.pop_is_active
])
def update_rule(old, new):
"""
Update rule for running estimations,
dynamically adjusting sensitivity with every time step
to new data (see Eq. 10 in the paper).
"""
nonlocal step
step += 1
adj_beta = beta / (1 - (1 - beta)**step)
return (1 - adj_beta) * old + adj_beta * new
x_means = np.stack([x.mean(axis=0), np.square(x).mean(axis=0)], axis=1)
# Updating normalization parameters (for ART)
# import functools ?
online_mean, online_mean_of_square = reduce(
update_rule, x_means,
np.array([old_online_mean, old_online_mean_of_square]))
old_std_dev = np.sqrt(old_online_mean_of_square -
np.square(old_online_mean))
std_dev = np.sqrt(online_mean_of_square - np.square(online_mean))
old_std_dev = old_std_dev if old_std_dev > 0 else std_dev
# Performing POP (Preserve the Output Precisely) update
# but only if we are not in the beginning of the training
# when both mean and std_dev are close to zero or still
# stabilizing. Otherwise POP kernel (W) and bias (b) can
# become very large and cause numerical instability.
std_is_stable = (step > self.min_steps and
np.abs(1 - old_std_dev / std_dev) < self.stable_rate)
if (int(pop_is_active) == 1
or (std_dev > self.epsilon and std_is_stable)):
new_kernel = old_std_dev * old_kernel / std_dev
new_bias = (
(old_std_dev * old_bias + old_online_mean - online_mean) /
std_dev)
pop_is_active = 1
else:
new_kernel, new_bias = old_kernel, old_bias
# Saving updated parameters into graph variables
var_update = [(self.kernel, new_kernel), (self.bias, new_bias),
(self.mean, online_mean),
(self.mean_of_square, online_mean_of_square),
(self.step, step), (self.pop_is_active, pop_is_active)]
K.batch_set_value(var_update)
return online_mean, std_dev
def reset_state(self):
num_thresholds = len(to_list(self.thresholds))
backend.batch_set_value([(v, np.zeros((num_thresholds, ))) for v in (
self.true_positives,
self.false_negatives,
self.true_negatives,
self.false_positives,
)])
def LR_mut(model, mutated_layer_indices=None):
LR_model = utils.ModelUtils.model_copy(model, 'LR')
available_layer_indices = _LC_and_LR_scan(LR_model, mutated_layer_indices)
if len(available_layer_indices) == 0:
mylogger.warning(
'no appropriate layer to remove (input and output shape should be same)'
)
return None
# use logic: remove the last available layer
remove_layer_index = available_layer_indices[-1]
mylogger.info('choose to remove layer {}'.format(
LR_model.layers[remove_layer_index].name))
if model.__class__.__name__ == 'Sequential':
import keras
new_model = keras.models.Sequential()
for i, layer in enumerate(LR_model.layers):
if i != remove_layer_index:
new_layer = LayerUtils.clone(layer)
# new_layer.name += '_copy'
new_model.add(new_layer)
else:
new_model = utils.ModelUtils.functional_model_operation(
LR_model,
operation={
LR_model.layers[remove_layer_index].name: lambda x, layer: x
})
# update weights
assert len(new_model.layers) == len(model.layers) - 1
tuples = []
old_model_layers = {}
for layer in model.layers:
old_model_layers[layer.name] = layer
new_model_layers = {}
for layer in new_model.layers:
layer_name = layer.name
if layer_name.endswith('_copy_LR'):
key = layer_name[:-8]
else:
key = layer_name
new_model_layers[key] = layer
for layer_name in new_model_layers.keys():
layer_weights = old_model_layers[layer_name].get_weights()
for sw, w in zip(new_model_layers[layer_name].weights, layer_weights):
shape_sw = np.shape(sw)
shape_w = np.shape(w)
assert len(shape_sw) == len(shape_w)
assert shape_sw[0] == shape_w[0]
tuples.append((sw, w))
import keras.backend as K
K.batch_set_value(tuples)
return new_model
def assign_coco_heads_weights(model,
mrcnn_coco_pretrained_filename,
verbose=True):
'''Use specific coco pretrained weights to initialize padnet's actor cls, mask and bbox heads on A2D dataset.
model: a keras model or its inner model if it has one.
mrcnn_coco_pretrained_filename: file path to the coco pretrained weights to be loaded.
A2D : COCO
0 - BG : 0 - BG
1 - adult : 1 - person
2 - baby : 1 - person
3 - ball : 33 - sports ball
4 - bird : 15 - bird
5 - car : 3 - car
6 - cat : 16 - cat
7 - dog : 17 - dog
'''
with h5py.File(mrcnn_coco_pretrained_filename, mode='r') as f:
print("Assigning coco heads' weights ...")
# COCO matrix indices to load
coco_indices = [0, 1, 1, 33, 15, 3, 16, 17]
coco_bbox_indices = []
for ind in coco_indices:
coco_bbox_indices += list(range(ind * 4, (ind + 1) * 4))
mask_kernel, mask_bias = model.get_layer('rgb_mrcnn_mask').weights
coco_mask_kernel = np.array(
f['mrcnn_mask']['mrcnn_mask/kernel:0'])[:, :, :, coco_indices]
coco_mask_bias = np.array(
f['mrcnn_mask']['mrcnn_mask/bias:0'])[coco_indices]
actor_class_kernel, actor_class_bias = model.get_layer(
'mrcnn_actor_class_logits').weights
coco_class_kernel = np.array(
f['mrcnn_class_logits']
['mrcnn_class_logits/kernel:0'])[:, coco_indices]
coco_class_bias = np.array(
f['mrcnn_class_logits']['mrcnn_class_logits/bias:0'])[coco_indices]
bbox_kernel, bbox_bias = model.get_layer('mrcnn_bbox_fc').weights
coco_bbox_kernel = np.array(
f['mrcnn_bbox_fc']['mrcnn_bbox_fc/kernel:0'])[:, coco_bbox_indices]
coco_bbox_bias = np.array(
f['mrcnn_bbox_fc']['mrcnn_bbox_fc/bias:0'])[coco_bbox_indices]
weights_assign_tuples = [(mask_kernel, coco_mask_kernel),
(mask_bias, coco_mask_bias),
(actor_class_kernel, coco_class_kernel),
(actor_class_bias, coco_class_bias),
(bbox_kernel, coco_bbox_kernel),
(bbox_bias, coco_bbox_bias)]
if verbose:
print(weights_assign_tuples)
K.batch_set_value(weights_assign_tuples)
def add_direction_to_weights(v, eps, mapping, model):
idx = [0] + list(np.cumsum([np.prod(c) for c in mapping['shapes']]))
setters = []
for w in model.trainable_weights:
idw = mapping['names'].index(w.name)
setters.append(
(w, K.get_value(w) +
eps * v[idx[idw]:idx[idw + 1]].reshape(mapping['shapes'][idw])))
K.batch_set_value(setters)
def _embedding_run(self):
feed_dict = {}
for layer_name in self.embedding_layer_names:
embedding_model = Model(
inputs=self.model.input,
outputs=self.keras_embedding_tensors[layer_name])
layer_output = embedding_model.predict(self.validation_input)
feed_dict[layer_name] = layer_output
K.batch_set_value(
list(zip(self.embedding_tensors.values(), feed_dict.values())))
def _load_weights_from_hdf5_group(f,
layers):
"""
Implements topological (order-based) weight loading.
Parameters
----------
f : File
A pointer to a HDF5 group.
layers : list of np.array
List of target layers.
"""
filtered_layers = []
for layer in layers:
weights = layer.weights
if weights:
filtered_layers.append(layer)
layer_names = load_attributes_from_hdf5_group(f, "layer_names")
filtered_layer_names = []
for name in layer_names:
g = f[name]
weight_names = load_attributes_from_hdf5_group(g, "weight_names")
if weight_names:
filtered_layer_names.append(name)
layer_names = filtered_layer_names
if len(layer_names) != len(filtered_layers):
raise ValueError("You are trying to load a weight file "
"containing " + str(len(layer_names)) +
" layers into a model with " +
str(len(filtered_layers)) + " layers.")
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = load_attributes_from_hdf5_group(g, "weight_names")
weight_values = [np.asarray(g[weight_name]) for weight_name in weight_names]
layer = filtered_layers[k]
symbolic_weights = layer.weights
weight_values = _preprocess_weights_for_loading(
layer=layer,
weights=weight_values)
if len(weight_values) != len(symbolic_weights):
raise ValueError("Layer #" + str(k) +
" (named `" + layer.name +
"` in the current model) was found to "
"correspond to layer " + name +
" in the save file. "
"However the new layer " + layer.name +
" expects " + str(len(symbolic_weights)) +
" weights, but the saved weights have " +
str(len(weight_values)) +
" elements.")
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def partial_load_weights(self, model, f):
'''
Keras does not seem to support partially loading weights from one
model into another model. This function achieves the same purpose so
we can serialise the final RNN hidden state to disk.
TODO: find / engineer a more elegant and general approach
'''
flattened_layers = model.layers
# new file format
filtered_layers = []
for layer in flattened_layers:
weights = layer.weights
if weights:
filtered_layers.append(layer)
flattened_layers = filtered_layers
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
filtered_layer_names = []
for name in layer_names[:-1]: # -1 so we clip out the output layer
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
filtered_layer_names.append(name)
layer_names = filtered_layer_names
if len(layer_names) != len(flattened_layers):
raise Exception('You are trying to load a weight file '
'containing ' + str(len(layer_names)) +
' layers into a model with ' +
str(len(flattened_layers)) + ' layers.')
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
weight_values = [g[weight_name] for weight_name in weight_names]
layer = flattened_layers[k]
symbolic_weights = layer.weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def load_weights(self, filepath, excluded_layers=list()):
print("Custom Weights Loader")
'''Load all layer weights from a HDF5 save file.
'''
f = h5py.File(filepath, mode='r')
if hasattr(self, 'flattened_layers'):
# support for legacy Sequential/Merge behavior
flattened_layers = self.flattened_layers
else:
flattened_layers = self.layers
if 'nb_layers' in f.attrs:
# legacy format
nb_layers = f.attrs['nb_layers']
if nb_layers != len(flattened_layers):
raise Exception('You are trying to load a weight file '
'containing ' + str(nb_layers) +
' layers into a model with ' +
str(len(flattened_layers)) + '.')
for k in range(nb_layers):
g = f['layer_{}'.format(k)]
weights = [g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])]
flattened_layers[k].set_weights(weights)
else:
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names'] if n not in excluded_layers]
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
layer = flattened_layers[k]
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
f.close()
def load_weights_from_hdf5_group_by_name(self, f,
weights_to_ignore=None):
''' Name-based weight loading
(instead of topological weight loading).
Layers that have no matching name are skipped.
'''
import keras.backend as K
if hasattr(self, 'flattened_layers'):
# Support for legacy Sequential/Merge behavior.
flattened_layers = self.flattened_layers
else:
flattened_layers = self.layers
if 'nb_layers' in f.attrs:
raise Exception('The weight file you are trying to load is' +
' in a legacy format that does not support' +
' name-based weight loading.')
else:
# New file format.
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
# Reverse index of layer name to list of layers with name.
index = {}
for layer in flattened_layers:
if layer.name:
index.setdefault(layer.name, []).append(layer)
# We batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
weight_values = [g[weight_name] for weight_name in weight_names]
for layer in index.get(name, []):
symbolic_weights = layer.weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'") expects ' +
str(len(symbolic_weights)) +
' weight(s), but the saved weights' +
' have ' + str(len(weight_values)) +
' element(s).')
# Set values.
for i in range(len(weight_values)):
# ignore to update this weight if applicable
if weights_to_ignore:
if symbolic_weights[i] in weights_to_ignore:
continue
weight_value_tuples.append((symbolic_weights[i], weight_values[i]))
K.batch_set_value(weight_value_tuples)
def reload_model(self, modelname, epoch):
print('%d END =====================' % epoch)
print('reload best_model.weights, set lr to 1e-4.')
self.logger.info('reload best_model.weights, set lr to 1e-4.')
self.stage = 1
model.load_weights(modelname)
EMAer.initialize()
K.set_value(self.model.optimizer.lr, 1e-4)
K.set_value(self.model.optimizer.iterations, 0)
opt_weights = K.batch_get_value(self.model.optimizer.weights)
opt_weights = [w * 0. for w in opt_weights]
K.batch_set_value(zip(self.model.optimizer.weights, opt_weights))
def partial_load_weights(self, model, f):
'''
Keras does not seem to support partially loading weights from one
model into another model. This function achieves the same purpose so
we can serialise the final RNN hidden state to disk.
TODO: find / engineer a more elegant and general approach
'''
flattened_layers = model.layers
# new file format
filtered_layers = []
for layer in flattened_layers:
weights = layer.weights
if weights:
filtered_layers.append(layer)
flattened_layers = filtered_layers
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
filtered_layer_names = []
for name in layer_names[:-1]: # -1 so we clip out the output layer
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
filtered_layer_names.append(name)
layer_names = filtered_layer_names
if len(layer_names) != len(flattened_layers):
raise Exception('You are trying to load a weight file '
'containing ' + str(len(layer_names)) +
' layers into a model with ' +
str(len(flattened_layers)) + ' layers.')
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
weight_values = [g[weight_name] for weight_name in weight_names]
layer = flattened_layers[k]
symbolic_weights = layer.weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) + ' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) + ' elements.')
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def load_weights(self, model, weights_path=None):
from keras import backend as K
if not weights_path:
weights_path = self.get_weights_filepath_best()
if not os.path.isfile(weights_path):
raise Exception("File does not exist.")
import h5py
f = h5py.File(weights_path, mode='r')
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
if len(layer_names) != len(model.layers):
print("Warning: Layer count different")
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
layer = model.get_layer(name=name)
if layer and len(weight_names):
weight_values = [
g[weight_name] for weight_name in weight_names
]
if not hasattr(layer, 'trainable_weights'):
print(
"Layer %s (%s) has no trainable weights, but we tried to load it."
% (name, type(layer).__name__))
else:
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception(
'Layer #' + str(k) + ' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) + ' elements.')
weight_value_tuples += list(
zip(symbolic_weights, weight_values))
K.batch_set_value(weight_value_tuples)
f.close()
def _load_weights_from_hdf5_group_by_name(f, layers):
"""
Implements name-based weight loading.
Parameters
----------
f : File
A pointer to a HDF5 group.
layers : list of np.array
List of target layers.
"""
# New file format.
layer_names = load_attributes_from_hdf5_group(f, "layer_names")
# Reverse index of layer name to list of layers with name.
index = {}
for layer in layers:
if layer.name:
index.setdefault(layer.name, []).append(layer)
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = load_attributes_from_hdf5_group(g, "weight_names")
weight_values = [
np.asarray(g[weight_name]) for weight_name in weight_names
]
for layer in index.get(name, []):
symbolic_weights = layer.weights
weight_values = _preprocess_weights_for_loading(
layer=layer, weights=weight_values)
if len(weight_values) != len(symbolic_weights):
warnings.warn(
"Skipping loading of weights for layer {} due to mismatch in number of weights ({} vs"
" {}).".format(layer, len(symbolic_weights),
len(weight_values)))
continue
# Set values.
for i in range(len(weight_values)):
symbolic_shape = K.int_shape(symbolic_weights[i])
if symbolic_shape != weight_values[i].shape:
warnings.warn(
"Skipping loading of weights for layer {} due to mismatch in shape ({} vs"
" {}).".format(layer, symbolic_weights[i].shape,
weight_values[i].shape))
continue
else:
weight_value_tuples.append(
(symbolic_weights[i], weight_values[i]))
K.batch_set_value(weight_value_tuples)
def load_prednet_weights(weights_path, prednet_model):
"""
Load model weights from HDF5 directly and set weights tensor by tensor.
This implementation is specific for a PredNet model.
This is workaround for some issues related to HDF5 loading on Google Colab:
OSError: Unable to open file (File signature not found)
:param prednet_model: Keras model instance to set the weights
:param weights_path: path for HDF5 weights file
"""
weights = h5py.File(weights_path)
weight_keys = list(weights.keys())
if 'model_weights' in weight_keys:
weights = weights['model_weights']
weight_keys = list(weights.keys())
prednet_key = None
for key in weight_keys:
if 'prednet' in key.replace('_', ''):
prednet_key = key
break
if prednet_key is None:
raise ValueError('Weights for prednet layer not found')
prednet_weights_keys = list(weights[prednet_key].keys())
prednet_weights = weights[prednet_key][prednet_weights_keys[0]]
total_weights = 0
weight_value_tuples = []
for layer_key in prednet_weights:
layer_weights = prednet_weights[layer_key]
total_weights += len(layer_weights)
for weight_key in layer_weights:
# print(f'Loading weights for layer {layer_key}, {weight_key} shape = {layer_weights[weight_key].shape}')
tensor_name = f'{layer_key}/{weight_key}'
for tensor in prednet_model.layers[1].weights:
if tensor_name in tensor.name:
# print(f'Setting tensor {tensor.name} to value in weights[{tensor_name}] - shape = {layer_weights[weight_key].shape}')
weight_value_tuples.append(
(tensor, layer_weights[weight_key]))
if weight_value_tuples:
K.batch_set_value(weight_value_tuples)
print(
f'{len(weight_value_tuples)}/{total_weights} weights loaded from {weights_path}'
)
def XXXset_layer_weights(self, input_weights):
"""
set the weights of the current model to the input weights...
"""
#for name, val in results:
jlayer = 0
weight_value_tuples = []
for layer in self.model.layers:
weight_values = input_weights[jlayer]
jlayer += 1
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def XXXset_layer_weights(self, input_weights):
"""
set the weights of the current model to the input weights...
"""
#for name, val in results:
jlayer=0
weight_value_tuples = []
for layer in self.model.layers:
weight_values = input_weights[jlayer]
jlayer += 1
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def on_epoch_end(self, epoch, logs=None):
EMAer.apply_ema_weights()
#data N decoder_model encoder_model tag
erase = []
for i1, i2 in enumerate(data):
if len(i2) == 1:
self.result["data"].append(i2)
self.result["tag"].append(tag[i1])
erase.append(i1)
continue
Nnew = []
datanew = []
i3 = 0
while i3 + 1 < len(i2):
o1, o2 = decoder_model.predict(
np.concatenate([i2[i3], i2[i3 + 1]], -1))
if self.ju_juli(i2[i3], i2[i3 + 1], o1, o2, N[i1][i3],
N[i1][i3 + 1], tag[i1]):
datanew.append(
encoder_model.predict(
np.concatenate([i2[i3], i2[i3 + 1]], -1)))
Nnew.append(N[i1][i3] + N[i1][i3 + 1])
i3 = i3 + 1
else:
datanew.append(i2[i3])
Nnew.append(N[i1][i3])
if i3 + 2 == len(i2):
datanew.append(i2[i3 + 1])
Nnew.append(N[i1][i3 + 1])
i3 = i3 + 1
data[i1] = datanew
N[i1] = Nnew
for i in erase:
del data[i]
del N[i]
if len(erase) / len(data) > self.chulin:
self.chulin = len(erase) / len(data)
print("处理个数", self.chulin)
rae_model.save_weights('best_model.weights')
EMAer.reset_old_weights()
if epoch + 1 == 50 or (self.stage == 0 and epoch > 10):
self.stage = 1
rae_model.load_weights('best_model.weights')
EMAer.initialize()
K.set_value(self.model.optimizer.lr, 1e-4)
K.set_value(self.model.optimizer.iterations, 0)
opt_weights = K.batch_get_value(self.model.optimizer.weights)
opt_weights = [w * 0. for w in opt_weights]
K.batch_set_value(zip(self.model.optimizer.weights, opt_weights))
def load_weights(model, weights_path):
from keras import backend as K
if not os.path.isfile(weights_path):
raise Exception("File does not exist.")
import h5py
f = h5py.File(weights_path, mode='r')
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
if len(layer_names) != len(model.layers):
print("Warning: Layer count different")
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
layer = model.get_layer(name=name)
if layer and len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
if not hasattr(layer, 'trainable_weights'):
print("Layer %s (%s) has no trainable weights, but we tried to load it." % (
name, type(layer).__name__))
else:
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
weight_value_tuples += list(zip(symbolic_weights, weight_values))
K.batch_set_value(weight_value_tuples)
f.close()
def loadKerasModelParameters(model, params):
"""
Helper function to load saved parameters into a keras model.
Code adapted from keras internals.
"""
layer_names = [n.decode('utf8') for n in params['layer_names']]
if len(layer_names) != len(model.layers):
raise Exception('Number of layers in `params` greater than number of layers in `model`')
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = params[name]
weight_names = [n.decode('utf8') for n in g['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
layer = model.layers[k]
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) + " has incorrect number of weights")
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
def load_weights(model, filepath):
"""Load all weights possible into model from filepath.
This is a modified version of keras load_weights that loads as much as it can
if there is a mismatch between file and model. It returns the weights
of the first layer in which the mismatch has happened
"""
print('Loading', filepath, 'to', model.name)
with h5py.File(filepath, mode='r') as f:
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for name in layer_names:
print(name)
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
try:
layer = model.get_layer(name=name)
except:
layer = None
if not layer:
print('failed to find layer', name, 'in model')
print('weights', ' '.join(str_shape(w) for w in weight_values))
print('stopping to load all other layers')
weight_values = [np.array(w) for w in weight_values]
break
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
weight_value_tuples += zip(symbolic_weights, weight_values)
weight_values = None
K.batch_set_value(weight_value_tuples)
return weight_values
def load_weights_from_hdf5_group(self, f,
weights_to_ignore=None):
'''Weight loading is based on layer order in a list
(matching model.flattened_layers for Sequential models,
and model.layers for Model class instances), not
on layer names.
Layers that have no weights are skipped.
'''
import keras.backend as K
import numpy as np
if hasattr(self, 'flattened_layers'):
# Support for legacy Sequential/Merge behavior.
flattened_layers = self.flattened_layers
else:
flattened_layers = self.layers
if 'nb_layers' in f.attrs:
# Legacy format.
nb_layers = f.attrs['nb_layers']
if nb_layers != len(flattened_layers):
raise Exception('You are trying to load a weight file '
'containing ' + str(nb_layers) +
' layers into a model with ' +
str(len(flattened_layers)) + ' layers.')
for k in range(nb_layers):
g = f['layer_{}'.format(k)]
weights = [g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])]
flattened_layers[k].set_weights(weights)
else:
# New file format.
filtered_layers = []
for layer in flattened_layers:
weights = layer.weights
if weights:
filtered_layers.append(layer)
flattened_layers = filtered_layers
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
filtered_layer_names = []
for name in layer_names:
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
filtered_layer_names.append(name)
layer_names = filtered_layer_names
if len(layer_names) != len(flattened_layers):
raise Exception('You are trying to load a weight file '
'containing ' + str(len(layer_names)) +
' layers into a model with ' +
str(len(flattened_layers)) + ' layers.')
# We batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
for k, name in enumerate(layer_names):
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
weight_values = [g[weight_name] for weight_name in weight_names]
layer = flattened_layers[k]
symbolic_weights = layer.weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
if layer.__class__.__name__ == 'Convolution1D':
# This is for backwards compatibility with
# the old Conv1D weights format.
w = weight_values[0]
shape = w.shape
if shape[:2] != (layer.filter_length, 1) or shape[3] != layer.nb_filter:
# Legacy shape: (self.nb_filter, input_dim, self.filter_length, 1)
assert shape[0] == layer.nb_filter and shape[2:] == (layer.filter_length, 1)
w = np.transpose(w, (2, 3, 1, 0))
weight_values[0] = w
for weight, value in zip(symbolic_weights, weight_values):
# ignore to update this weight if applicable
if weights_to_ignore:
if weight in weights_to_ignore:
continue
weight_value_tuples.append((weight, value))
K.batch_set_value(weight_value_tuples)
weight_values = [g[weight_name] for weight_name in weight_names]
layer = model.layers[k]
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if len(weight_values) != len(symbolic_weights):
raise Exception('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
weight_value_tuples += zip(symbolic_weights, weight_values)
K.batch_set_value(weight_value_tuples)
f.close()
print('Model loaded.')
layer_dict = dict([(layer.name, layer) for layer in model.layers])
def normalize(x):
return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)
def deprocess_image(x):
x -= x.mean()
x /= (x.std() + 1e-5)
x *= 0.1
x += 0.5
def load_partial_weights(model, file_path):
"""Load partial layer weights from a HDF5 save file.
"""
import h5py
f = h5py.File(file_path, mode='r')
if hasattr(model, 'flattened_layers'):
# support for legacy Sequential/Merge behavior
flattened_layers = model.flattened_layers
else:
flattened_layers = model.layers
if 'nb_layers' in f.attrs:
for k in range(len(flattened_layers)):
g = f['layer_{}'.format(k)]
weights = [g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])]
flattened_layers[k].set_weights(weights)
else:
print('nb_layers attribute missing in given file')
# new file format
layer_names = [n.decode('utf8') for n in f.attrs['layer_names']]
if len(layer_names) != len(flattened_layers):
print('You are trying to load a weight file '
'containing ' + str(len(layer_names)) +
' layers into a model with ' +
str(len(flattened_layers)) + ' layers.')
# we batch weight value assignments in a single backend call
# which provides a speedup in TensorFlow.
weight_value_tuples = []
layer_count = 0
print layer_names
print len(flattened_layers)
model_k = 0
for k, name in enumerate(layer_names):
# Suriya debug
print k
layer_count += 1
if layer_count >= len(flattened_layers):
continue
g = f[name]
weight_names = [n.decode('utf8') for n in g.attrs['weight_names']]
if len(weight_names):
weight_values = [g[weight_name] for weight_name in weight_names]
if debug:
for weight_value in weight_values:
print('Weight value name: {}'.format(weight_value))
print('Weight value shape: {}'.format(weight_value.shape))
if model_k >= len(flattened_layers):
continue
layer = flattened_layers[model_k]
print('model_layer: {}, saved_layer: {}'.format(layer.name, name))
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if (len(weight_values) != len(symbolic_weights)) and (layer.name != name):
print('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
model_k += 1
layer = flattened_layers[model_k]
print('Layers after forwarding through the model')
print('model_layer: {}, saved_layer: {}'.format(layer.name, name))
symbolic_weights = layer.trainable_weights + layer.non_trainable_weights
if (len(weight_values) != len(symbolic_weights)) and (layer.name != name):
print('Layer #' + str(k) +
' (named "' + layer.name +
'" in the current model) was found to '
'correspond to layer ' + name +
' in the save file. '
'However the new layer ' + layer.name +
' expects ' + str(len(symbolic_weights)) +
' weights, but the saved weights have ' +
str(len(weight_values)) +
' elements.')
weight_value_tuples += zip(symbolic_weights, weight_values)
model_k += 1
K.batch_set_value(weight_value_tuples)
f.close()
def _restore_keras(self, keras_model, filename):
""" Loads a native Keras model.
"""
import keras.backend as K # pylint: disable=import-error
path = os.path.expanduser(os.path.expandvars(filename))
if os.path.exists(path):
if not os.path.isdir(path):
raise ValueError('Target weight exists, but it is not a '
'directory. Kur expected a directory that it can work '
'with. Please move or delete the existing path: {}'
.format(path))
else:
raise ValueError('Target weight directory does not exist: {}'
.format(path))
layers = keras_model.flattened_layers \
if hasattr(keras_model, 'flattened_layers') else keras_model.layers
# Get a map from "layer name" to "layer instance" in the current model.
index = {}
for layer in layers:
if layer.name:
index.setdefault(layer.name, []).append(layer)
# Enumerate all of the saved tensors, organized like this:
# tensors = {
# 'layer_1_name' : {
# 'weight_1_name' : '/path/to/file',
# ...,
# },
# ...
# }
tensors = self.enumerate_saved_tensors(path)
# We want to put (symbolic_weights, weight_values) tuples in this.
weight_value_tuples = []
# Loop over the available weights.
for layer_name, weights in tensors.items():
# Load the weights.
# This maps weight names to numpy arrays.
weights = {k : idx.load(v) for k, v in weights.items()}
# Now assign all of the weights to their corresponding symbolic
# weights. Loop over all layers which use this name.
for layer in index.get(layer_name, []):
# Get the symbolic weights.
symbolic_weights = layer.weights
# Get the associated names (so we know what order to assign the
# weights in.
weight_names, _ = \
self._get_weight_names_and_values_from_symbolic(
symbolic_weights
)
available = set(weights.keys())
needed = set(name.replace('/', '_') for name in weight_names)
if available ^ needed:
logger.error('Weight discrepancy in the weights we are '
'supposed to load.')
logger.error('These weights are on-disk, but not '
'requested: %s', ', '.join(available - needed))
logger.error('These weights were requested, but not '
'available: %s', ', '.join(needed - available))
raise ValueError('Layer "{}" expected {} weights, but we '
'found {} on disk.'.format(layer_name,
len(needed), len(available)))
for i, name in enumerate(weight_names):
name = name.replace('/', '_')
weight_value_tuples.append((symbolic_weights[i], weights[name]))
# Assign all the weights in one batch (for efficiency).
K.batch_set_value(weight_value_tuples)
