def load_weights(self, filepath, by_name=False, exclude=None):
"""Modified version of the correspoding Keras function with
the addition of multi-GPU support and the ability to exclude
some layers from loading.
exlude: list of layer names to excluce
"""
import h5py
from keras.engine import topology
if exclude:
by_name = True
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
f = h5py.File(filepath, mode='r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
# In multi-GPU training, we wrap the model. Get layers
# of the inner model because they have the weights.
keras_model = self.keras_model
layers = keras_model.inner_model.layers if hasattr(keras_model, "inner_model") \
else keras_model.layers
# Exclude some layers
if exclude:
layers = filter(lambda l: l.name not in exclude, layers)
if by_name:
topology.load_weights_from_hdf5_group_by_name(f, layers)
else:
topology.load_weights_from_hdf5_group(f, layers)
if hasattr(f, 'close'):
f.close()
def load_weight(self, filepath, by_name=False, exclude=None):
import h5py
from keras.engine import topology
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
f = h5py.File(filepath, mode='r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
# In multi-GPU training, get layers of inner model
keras_model = self.keras_model
layers = keras_model.inner_model.layers if hasattr(
keras_model, "inner_model") else keras_model.layers
# Exclude some layers
if exclude:
by_name = True
layers = filter(lambda l: l.name not in exclude, layers)
if by_name:
topology.load_weights_from_hdf5_group_by_name(f, layers)
else:
topology.load_weights_from_hdf5_group(f, layers)
if hasattr(f, 'close'):
f.close()
# Update the log directory
self.set_log_dir(filepath)
def _import_mv_weights(self, model: Model, file_name: str):
f = h5py.File(file_name, mode='r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
load_weights_from_hdf5_group_by_name(f, [
layer
for layer in model.layers if fnmatch.fnmatch(layer.name, "mv_*")
])
def load_weights(self, filepath, by_name=False, exclude=None):
"""
Modified version of the correspoding Keras function with
the addition of multi-GPU support and the ability to exclude
some layers from loading.
exlude: list of layer names to excluce
"""
import h5py
from keras.engine import topology
print('>>> load_weights()')
if exclude:
by_name = True
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
log(' load_weights: Loading weights from: {}'.format(filepath))
f = h5py.File(filepath, mode='r')
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
# In multi-GPU training, we wrap the model. Get layers
# of the inner model because they have the weights.
keras_model = self.keras_model
layers = keras_model.inner_model.layers if hasattr(keras_model, "inner_model")\
else keras_model.layers
# Exclude some layers
if exclude:
layers = filter(lambda l: l.name not in exclude, layers)
# print(' layers to load ' )
# print('----------------' )
# for idx,layer in enumerate(layers):
# print('>layer {} : name : {:40s} type: {}'.format(idx,layer.name,layer))
if by_name:
topology.load_weights_from_hdf5_group_by_name(f, layers)
else:
topology.load_weights_from_hdf5_group(f, layers)
if hasattr(f, 'close'):
f.close()
log(' load_weights: Log directory set to : {}'.format(filepath))
# Update the log directory
self.set_log_dir(filepath)
print(' Load weights complete : ', filepath)
return (filepath)
def load_model(self, model_path):
with h5py.File(model_path, 'r') as f:
for model in self.models:
try:
hdf5_group = f[model.name]
except KeyError:
print('Given HDF5 file ({hdf}) does not '
'contain model {model}. Skipping.'.format(
model=model.name, hdf=model_path))
else:
kwargs = {}
if 'skip_mismatch' in (load_weights_from_hdf5_group_by_name
.__code__.co_varnames):
kwargs['skip_mismatch'] = True
load_weights_from_hdf5_group_by_name(
hdf5_group, model.layers, **kwargs)
load_optimizer_weights(model, hdf5_group)
def ResNet50(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
layers=50):
"""Instantiates the ResNet50 architecture.
Optionally loads weights pre-trained on ImageNet.
Note that the data format convention used by the model is
the one specified in your Keras config at `~/.keras/keras.json`.
When using TensorFlow, for best performance you should
set `"image_data_format": "channels_last"` in the config.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is False (otherwise the input shape
has to be `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 197.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
assert layers in [18, 34, 50, 101, 152]
use_bn = (layers == 50)
basic = (layers in [18, 34])
if layers == 18:
num_layers = [2, 2, 2, 2]
elif layers == 34:
num_layers = [3, 4, 6, 3]
elif layers == 50:
num_layers = [3, 4, 6, 3]
elif layers == 101:
num_layers = [3, 4, 23, 3]
elif layers == 152:
num_layers = [3, 8, 36, 3]
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=197,
data_format=K.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if K.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
if basic:
x = Conv2D(64, (7, 7), strides=(2, 2), padding='same',
name='conv1')(img_input)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = ResNetBlock(3, [64, 64, 256],
stage=2,
block='a',
use_bn=use_bn,
basic=basic)(x)
else:
x = ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), padding='valid',
name='conv1')(x)
if use_bn:
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = ResNetBlock(3, [64, 64, 256],
stage=2,
block='a',
strides=(1, 1),
use_bn=use_bn,
basic=basic)(x)
for i in range(num_layers[0] - 1):
x = ResNetBlock(3, [64, 64, 256],
stage=2,
block=chr(ord('b') + i),
identity=True,
use_bn=use_bn,
basic=basic)(x)
x = ResNetBlock(3, [128, 128, 512],
stage=3,
block='a',
use_bn=use_bn,
basic=basic)(x)
for i in range(num_layers[1] - 1):
x = ResNetBlock(3, [128, 128, 512],
stage=3,
block=chr(ord('b') + i),
identity=True,
use_bn=use_bn,
basic=basic)(x)
x = ResNetBlock(3, [256, 256, 1024],
stage=4,
block='a',
use_bn=use_bn,
basic=basic)(x)
for i in range(num_layers[2] - 1):
x = ResNetBlock(3, [256, 256, 1024],
stage=4,
block=chr(ord('b') + i),
identity=True,
use_bn=use_bn,
basic=basic)(x)
x = ResNetBlock(3, [512, 512, 2048],
stage=5,
block='a',
use_bn=use_bn,
basic=basic)(x)
for i in range(num_layers[3] - 1):
x = ResNetBlock(3, [512, 512, 2048],
stage=5,
block=chr(ord('b') + i),
identity=True,
use_bn=use_bn,
basic=basic)(x)
if basic:
x = GlobalAveragePooling2D()(x)
else:
x = AveragePooling2D((7, 7), name='avg_pool')(x)
x = Flatten()(x)
x = Dense(classes, activation='softmax', name='fc1000')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='resnet50')
# load weights
if weights == 'imagenet' and layers == 50:
if include_top:
weights_path = get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
md5_hash='a7b3fe01876f51b976af0dea6bc144eb')
else:
weights_path = get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
with h5py.File(weights_path, mode='r') as f:
if 'layer_names' not in f.attrs and 'model_weights' in f:
f = f['model_weights']
import itertools
all_layers = [
[l] if not isinstance(l, ResNetBlock) else l.get_layers()
for l in model.layers
]
all_layers = list(itertools.chain.from_iterable(all_layers))
load_weights_from_hdf5_group_by_name(f, all_layers)
if K.backend() == 'theano':
layer_utils.convert_all_kernels_in_model(model)
return model
def load_weights(self,
filepath,
by_name=False,
exclude=None,
new_folder=False):
'''
Modified version of the correspoding Keras function with
the addition of multi-GPU support and the ability to exclude
some layers from loading.
exlude: list of layer names to excluce
'''
import h5py
from keras.engine import topology
log(' >>> load_weights() from : {}'.format(filepath))
if exclude:
by_name = True
if h5py is None:
raise ImportError('`load_weights` requires h5py.')
f = h5py.File(filepath, mode='r')
pp.pprint(f.__dict__)
if 'layer_names' not in f.attrs and 'model_weights' in f:
print('im here')
f = f['model_weights']
else:
print('im not here')
# In multi-GPU training, we wrap the model. Get layers
# of the inner model because they have the weights.
keras_model = self.keras_model
layers = keras_model.inner_model.layers if hasattr(keras_model, "inner_model")\
else keras_model.layers
print('\n\n')
print('--------------------------------')
print(' List of all Layers in Model ')
print('--------------------------------')
print('\n\n')
for idx, layer in enumerate(layers):
print('>layer {} : name : {:40s} type: {}'.format(
idx, layer.name, layer))
# Exclude some layers
if exclude:
layers = filter(lambda l: l.name not in exclude, layers)
print(' --------------------------------------')
print(' layers to load (not in exclude list) ')
print(' --------------------------------------')
for idx, layer in enumerate(layers):
print(' >layer {} : name : {:40s} type: {}'.format(
idx, layer.name, layer))
print('\n\n')
if by_name:
topology.load_weights_from_hdf5_group_by_name(f, layers)
else:
topology.load_weights_from_hdf5_group(f, layers)
if hasattr(f, 'close'):
f.close()
# Update the log directory
print(' Weights file loaded: {} '.format(filepath))
print(' Weights file loaded: {} '.format(filepath),
file=sys.__stdout__)
if self.mode == 'training':
self.set_log_dir(filepath, new_folder)
print(" MODEL Load weight file COMPLETE ")
return (filepath)
def load_weights(self, weights_path):
from keras.engine import topology
import h5py
f = h5py.File(weights_path)
layers = self.keras_model.layers
topology.load_weights_from_hdf5_group_by_name(f, layers)
