def VGG16_BN(input_tensor=None, input_shape=None, classes=10, conv_dropout=0.4, dropout=0.5, activation='relu'):
"""Instantiates the VGG16 architecture with Batch Normalization
# Arguments
input_tensor: Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model.
input_shape: shape tuple
classes: optional number of classes to classify images
# Returns
A Keras model instance.
"""
img_input = Input(shape=input_shape) if input_tensor is None else (
Input(tensor=input_tensor, shape=input_shape) if not K.is_keras_tensor(input_tensor) else input_tensor
)
# Block 1
x = conv_block(64, dropout=0.3, activation=activation, block=1, layer=1)(img_input)
x = conv_block(64, dropout=0, activation=activation, block=1, layer=2)(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = conv_block(128, dropout=conv_dropout, activation=activation, block=2, layer=1)(x)
x = conv_block(128, dropout=0, activation=activation, block=2, layer=2)(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = conv_block(256, dropout=conv_dropout, activation=activation, block=3, layer=1)(x)
x = conv_block(256, dropout=conv_dropout, activation=activation, block=3, layer=2)(x)
x = conv_block(256, dropout=0, activation=activation, block=3, layer=3)(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = conv_block(512, dropout=conv_dropout, activation=activation, block=4, layer=1)(x)
x = conv_block(512, dropout=conv_dropout, activation=activation, block=4, layer=2)(x)
x = conv_block(512, dropout=0, activation=activation, block=4, layer=3)(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
# Block 5
x = conv_block(512, dropout=conv_dropout, activation=activation, block=5, layer=1)(x)
x = conv_block(512, dropout=conv_dropout, activation=activation, block=5, layer=2)(x)
x = conv_block(512, dropout=0, activation=activation, block=5, layer=3)(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
# Flatten
x = GlobalAveragePooling2D()(x)
# FC Layers
x = dense_block(512, dropout=dropout, activation=activation, name='fc1')(x)
x = dense_block(512, dropout=dropout, activation=activation, name='fc2')(x)
# Classification block
x = Dense(classes, activation='softmax', name='predictions')(x)
# Ensure that the model takes into account any potential predecessors of `input_tensor`.
inputs = get_source_inputs(input_tensor) if input_tensor is not None else img_input
# Create model.
return Model(inputs, x, name='vgg16_bn')
def SEDenseNet(input_shape=None,
depth=40,
nb_dense_block=3,
growth_rate=12,
nb_filter=-1,
nb_layers_per_block=-1,
bottleneck=False,
reduction=0.0,
dropout_rate=0.0,
weight_decay=1e-4,
subsample_initial_block=False,
include_top=True,
weights=None,
input_tensor=None,
classes=10,
activation='softmax'):
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=32,
min_size=8,
data_format=K.image_data_format(),
require_flatten=include_top)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = __create_dense_net(classes, img_input, include_top, depth,
nb_dense_block, growth_rate, nb_filter,
nb_layers_per_block, bottleneck, reduction,
dropout_rate, weight_decay, subsample_initial_block,
activation)
# 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='se-densenet')
return model
def InceptionResNetV2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
#global backend, layers, models, keras_utils
#backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=75,
data_format=backend.image_data_format(),
require_flatten=False,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Stem block: 35 x 35 x 192
x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid')
x = conv2d_bn(x, 32, 3, padding='valid')
x = conv2d_bn(x, 64, 3)
x = layers.MaxPooling2D(3, strides=2)(x)
x = conv2d_bn(x, 80, 1, padding='valid')
x = conv2d_bn(x, 192, 3, padding='valid')
x = layers.MaxPooling2D(3, strides=2)(x)
# Mixed 5b (Inception-A block): 35 x 35 x 320
branch_0 = conv2d_bn(x, 96, 1)
branch_1 = conv2d_bn(x, 48, 1)
branch_1 = conv2d_bn(branch_1, 64, 5)
branch_2 = conv2d_bn(x, 64, 1)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_pool = layers.AveragePooling2D(3, strides=1, padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1)
branches = [branch_0, branch_1, branch_2, branch_pool]
channel_axis = 1 if backend.image_data_format() == 'channels_first' else 3
x = layers.Concatenate(axis=channel_axis, name='mixed_5b')(branches)
# 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
for block_idx in range(1, 11):
x = inception_resnet_block(x,
scale=0.17,
block_type='block35',
block_idx=block_idx)
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 256, 3)
branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='valid')
branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
x = layers.Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
for block_idx in range(1, 21):
x = inception_resnet_block(x,
scale=0.1,
block_type='block17',
block_idx=block_idx)
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
branch_0 = conv2d_bn(x, 256, 1)
branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='valid')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='valid')
branch_2 = conv2d_bn(x, 256, 1)
branch_2 = conv2d_bn(branch_2, 288, 3)
branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='valid')
branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = layers.Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
for block_idx in range(1, 10):
x = inception_resnet_block(x,
scale=0.2,
block_type='block8',
block_idx=block_idx)
x = inception_resnet_block(x,
scale=1.,
activation=None,
block_type='block8',
block_idx=10)
# Final convolution block: 8 x 8 x 1536
x = conv2d_bn(x, 1536, 1, name='conv_7b')
if include_top:
# Classification block
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(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='inception_resnet_v2')
return model
def MobileNetV2(input_shape=None,
alpha=1.0,
include_top=True,
weights='imagenet',
input_tensor=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the MobileNetV2 architecture.
# Arguments
input_shape: optional shape tuple, to be specified if you would
like to use a model with an input img resolution that is not
(224, 224, 3).
It should have exactly 3 inputs channels (224, 224, 3).
You can also omit this option if you would like
to infer input_shape from an input_tensor.
If you choose to include both input_tensor and input_shape then
input_shape will be used if they match, if the shapes
do not match then we will throw an error.
E.g. `(160, 160, 3)` would be one valid value.
alpha: controls the width of the network. This is known as the
width multiplier in the MobileNetV2 paper, but the name is kept for
consistency with MobileNetV1 in Keras.
- If `alpha` < 1.0, proportionally decreases the number
of filters in each layer.
- If `alpha` > 1.0, proportionally increases the number
of filters in each layer.
- If `alpha` = 1, default number of filters from the paper
are used at each layer.
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.
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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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 or invalid alpha, rows when
weights='imagenet'
"""
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')
# Determine proper input shape and default size.
# If both input_shape and input_tensor are used, they should match
if input_shape is not None and input_tensor is not None:
try:
is_input_t_tensor = backend.is_keras_tensor(input_tensor)
except ValueError:
try:
is_input_t_tensor = backend.is_keras_tensor(
keras_utils.get_source_inputs(input_tensor))
except ValueError:
raise ValueError('input_tensor: ', input_tensor,
'is not type input_tensor')
if is_input_t_tensor:
if backend.image_data_format == 'channels_first':
if backend.int_shape(input_tensor)[1] != input_shape[1]:
raise ValueError(
'input_shape: ', input_shape, 'and input_tensor: ',
input_tensor,
'do not meet the same shape requirements')
else:
if backend.int_shape(input_tensor)[2] != input_shape[1]:
raise ValueError(
'input_shape: ', input_shape, 'and input_tensor: ',
input_tensor,
'do not meet the same shape requirements')
else:
raise ValueError('input_tensor specified: ', input_tensor,
'is not a keras tensor')
# If input_shape is None, infer shape from input_tensor
if input_shape is None and input_tensor is not None:
try:
backend.is_keras_tensor(input_tensor)
except ValueError:
raise ValueError('input_tensor: ', input_tensor, 'is type: ',
type(input_tensor), 'which is not a valid type')
if input_shape is None and not backend.is_keras_tensor(input_tensor):
default_size = 224
elif input_shape is None and backend.is_keras_tensor(input_tensor):
if backend.image_data_format() == 'channels_first':
rows = backend.int_shape(input_tensor)[2]
cols = backend.int_shape(input_tensor)[3]
else:
rows = backend.int_shape(input_tensor)[1]
cols = backend.int_shape(input_tensor)[2]
if rows == cols and rows in [96, 128, 160, 192, 224]:
default_size = rows
else:
default_size = 224
# If input_shape is None and no input_tensor
elif input_shape is None:
default_size = 224
# If input_shape is not None, assume default size
else:
if backend.image_data_format() == 'channels_first':
rows = input_shape[1]
cols = input_shape[2]
else:
rows = input_shape[0]
cols = input_shape[1]
if rows == cols and rows in [96, 128, 160, 192, 224]:
default_size = rows
else:
default_size = 224
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if backend.image_data_format() == 'channels_last':
row_axis, col_axis = (0, 1)
else:
row_axis, col_axis = (1, 2)
rows = input_shape[row_axis]
cols = input_shape[col_axis]
if weights == 'imagenet':
if alpha not in [0.35, 0.50, 0.75, 1.0, 1.3, 1.4]:
raise ValueError('If imagenet weights are being loaded, '
'alpha can be one of `0.35`, `0.50`, `0.75`, '
'`1.0`, `1.3` or `1.4` only.')
if rows != cols or rows not in [96, 128, 160, 192, 224]:
rows = 224
warnings.warn('MobileNet shape is undefined.'
' Weights for input shape'
'(224, 224) will be loaded.')
if backend.image_data_format() != 'channels_last':
warnings.warn('The MobileNet family of models is only available '
'for the input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height).'
' You should set `image_data_format="channels_last"` '
'in your Keras config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
backend.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
first_block_filters = _make_divisible(32 * alpha, 8)
x = layers.ZeroPadding2D(padding=correct_pad(backend, img_input, 3),
name='Conv1_pad')(img_input)
x = layers.Conv2D(first_block_filters,
kernel_size=3,
strides=(2, 2),
padding='valid',
use_bias=False,
name='Conv1')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name='bn_Conv1')(x)
x = layers.ReLU(6., name='Conv1_relu')(x)
x = _inverted_res_block(x,
filters=16,
alpha=alpha,
stride=1,
expansion=1,
block_id=0)
x = _inverted_res_block(x,
filters=24,
alpha=alpha,
stride=2,
expansion=6,
block_id=1)
x = _inverted_res_block(x,
filters=24,
alpha=alpha,
stride=1,
expansion=6,
block_id=2)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=2,
expansion=6,
block_id=3)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=1,
expansion=6,
block_id=4)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=1,
expansion=6,
block_id=5)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=2,
expansion=6,
block_id=6)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
expansion=6,
block_id=7)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
expansion=6,
block_id=8)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
expansion=6,
block_id=9)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
expansion=6,
block_id=10)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
expansion=6,
block_id=11)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
expansion=6,
block_id=12)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=2,
expansion=6,
block_id=13)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=1,
expansion=6,
block_id=14)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=1,
expansion=6,
block_id=15)
x = _inverted_res_block(x,
filters=320,
alpha=alpha,
stride=1,
expansion=6,
block_id=16)
# no alpha applied to last conv as stated in the paper:
# if the width multiplier is greater than 1 we
# increase the number of output channels
if alpha > 1.0:
last_block_filters = _make_divisible(1280 * alpha, 8)
else:
last_block_filters = 1280
x = layers.Conv2D(last_block_filters,
kernel_size=1,
use_bias=False,
name='Conv_1')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name='Conv_1_bn')(x)
x = layers.ReLU(6., name='out_relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(classes,
activation='softmax',
use_bias=True,
name='Logits')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs,
x,
name='mobilenetv2_%0.2f_%s' % (alpha, rows))
# Load weights.
if weights == 'imagenet':
if backend.image_data_format() == 'channels_first':
raise ValueError('Weights for "channels_first" format '
'are not available.')
if include_top:
model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' +
str(alpha) + '_' + str(rows) + '.h5')
weigh_path = BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weigh_path,
cache_subdir='models')
else:
model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' +
str(alpha) + '_' + str(rows) + '_no_top' + '.h5')
weigh_path = BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weigh_path,
cache_subdir='models')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
if old_data_format:
backend.set_image_data_format(old_data_format)
return model
def ResNet(model_params, input_shape=None, input_tensor=None, include_top=True,
classes=1000, weights='imagenet', create_encoder=False):
"""Instantiates the ResNet, SEResNet 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`.
Args:
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.
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 input_tensor is None:
img_input = layers.Input(shape=input_shape, name='data')
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# choose residual block type
ResidualBlock = model_params.residual_block
Attention = None
# get out intermidiate scales
scales = []
# get parameters for model layers
no_scale_bn_params = get_bn_params(scale=False)
bn_params = get_bn_params()
conv_params = get_conv_params()
init_filters = 64
# resnet bottom
x = layers.BatchNormalization(name='bn_data', **no_scale_bn_params)(img_input)
x = layers.ZeroPadding2D(padding=(3, 3))(x)
x = layers.Conv2D(init_filters, (7, 7), strides=(2, 2), name='conv0', **conv_params)(x)
x = layers.BatchNormalization(name='bn0', **bn_params)(x)
x = layers.Activation('relu', name='relu0')(x)
x = layers.ZeroPadding2D(padding=(1, 1))(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='valid', name='pooling0')(x)
# resnet body
for stage, rep in enumerate(model_params.repetitions):
for block in range(rep):
filters = init_filters * (2 ** stage)
# first block of first stage without strides because we have maxpooling before
if block == 0 and stage == 0:
x = ResidualBlock(filters, stage, block, strides=(1, 1),
cut='post', attention=Attention)(x)
elif block == 0:
x = ResidualBlock(filters, stage, block, strides=(2, 2),
cut='post', attention=Attention)(x)
else:
x = ResidualBlock(filters, stage, block, strides=(1, 1),
cut='pre', attention=Attention)(x)
if block == rep - 1:
scales.append(x)
x = layers.BatchNormalization(name='bn1', **bn_params)(x)
x = layers.Activation('relu', name='relu1')(x)
# resnet top
if include_top:
x = layers.GlobalAveragePooling2D(name='pool1')(x)
x = layers.Dense(classes, name='fc1')(x)
x = layers.Activation('softmax', name='softmax')(x)
# Ensure that the model takes into account any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
if not create_encoder:
model = Model(inputs, x)
return model
else:
return inputs, x, scales
def NASNet(input_shape=None,
penultimate_filters=4032,
num_blocks=6,
stem_block_filters=96,
skip_reduction=True,
filter_multiplier=2,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000,
default_size=None,
**kwargs):
'''Instantiates a NASNet model.
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`.
# Arguments
input_shape: Optional shape tuple, the input shape
is by default `(331, 331, 3)` for NASNetLarge and
`(224, 224, 3)` for NASNetMobile.
It should have exactly 3 input channels,
and width and height should be no smaller than 32.
E.g. `(224, 224, 3)` would be one valid value.
penultimate_filters: Number of filters in the penultimate layer.
NASNet models use the notation `NASNet (N @ P)`, where:
- N is the number of blocks
- P is the number of penultimate filters
num_blocks: Number of repeated blocks of the NASNet model.
NASNet models use the notation `NASNet (N @ P)`, where:
- N is the number of blocks
- P is the number of penultimate filters
stem_block_filters: Number of filters in the initial stem block
skip_reduction: Whether to skip the reduction step at the tail
end of the network.
filter_multiplier: Controls the width of the network.
- If `filter_multiplier` < 1.0, proportionally decreases the number
of filters in each layer.
- If `filter_multiplier` > 1.0, proportionally increases the number
of filters in each layer.
- If `filter_multiplier` = 1, default number of filters from the
paper are used at each layer.
include_top: Whether to include the fully-connected
layer at the top of the network.
weights: `None` (random initialization) or
`imagenet` (ImageNet weights)
input_tensor: Optional Keras tensor (i.e. output of
`layers.Input()`)
to use as image input for the model.
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.
default_size: Specifies the default image size of the model
# Returns
A Keras model instance.
# Raises
ValueError: In case of invalid argument for `weights`,
invalid input shape or invalid `penultimate_filters` value.
'''
# global backend, layers, models, keras_utils
# backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
if (isinstance(input_shape, tuple) and None in input_shape
and weights == 'imagenet'):
raise ValueError('When specifying the input shape of a NASNet'
' and loading `ImageNet` weights, '
'the input_shape argument must be static '
'(no None entries). Got: `input_shape=' +
str(input_shape) + '`.')
if default_size is None:
default_size = 331
# Determine proper input shape and default size.
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if backend.image_data_format() != 'channels_last':
warnings.warn('The NASNet family of models is only available '
'for the input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height).'
' You should set `image_data_format="channels_last"` '
'in your Keras config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
backend.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if penultimate_filters % 24 != 0:
raise ValueError(
'For NASNet-A models, the value of `penultimate_filters` '
'needs to be divisible by 24. Current value: %d' %
penultimate_filters)
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
filters = penultimate_filters // 24
x = layers.Conv2D(stem_block_filters, (3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
kernel_regularizer=l2(weight_decay),
name='stem_conv1',
kernel_initializer='he_normal')(img_input)
if use_bn:
x = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='stem_bn1')(x)
p = None
x, p = _reduction_a_cell(x,
p,
filters // (filter_multiplier**2),
block_id='stem_1')
x, p = _reduction_a_cell(x,
p,
filters // filter_multiplier,
block_id='stem_2')
for i in range(num_blocks):
x, p = _normal_a_cell(x, p, filters, block_id='%d' % (i))
x, p0 = _reduction_a_cell(x,
p,
filters * filter_multiplier,
block_id='reduce_%d' % (num_blocks))
p = p0 if not skip_reduction else p
for i in range(num_blocks):
x, p = _normal_a_cell(x,
p,
filters * filter_multiplier,
block_id='%d' % (num_blocks + i + 1))
x, p0 = _reduction_a_cell(x,
p,
filters * filter_multiplier**2,
block_id='reduce_%d' % (2 * num_blocks))
p = p0 if not skip_reduction else p
for i in range(num_blocks):
x, p = _normal_a_cell(x,
p,
filters * filter_multiplier**2,
block_id='%d' % (2 * num_blocks + i + 1))
x = layers.Activation('relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
model = models.Model(inputs, x, name='NASNet')
# Load weights.
if weights == 'imagenet':
if default_size == 224: # mobile version
if include_top:
weights_path = keras_utils.get_file(
'nasnet_mobile.h5',
NASNET_MOBILE_WEIGHT_PATH,
cache_subdir='models',
file_hash='020fb642bf7360b370c678b08e0adf61')
else:
weights_path = keras_utils.get_file(
'nasnet_mobile_no_top.h5',
NASNET_MOBILE_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='1ed92395b5b598bdda52abe5c0dbfd63')
model.load_weights(weights_path)
elif default_size == 331: # large version
if include_top:
weights_path = keras_utils.get_file(
'nasnet_large.h5',
NASNET_LARGE_WEIGHT_PATH,
cache_subdir='models',
file_hash='11577c9a518f0070763c2b964a382f17')
else:
weights_path = keras_utils.get_file(
'nasnet_large_no_top.h5',
NASNET_LARGE_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='d81d89dc07e6e56530c4e77faddd61b5')
model.load_weights(weights_path)
else:
raise ValueError(
'ImageNet weights can only be loaded with NASNetLarge'
' or NASNetMobile')
elif weights is not None:
model.load_weights(weights)
if old_data_format:
backend.set_image_data_format(old_data_format)
return model
def EfficientNet(input_shape,
block_args_list: List[BlockArgs],
width_coefficient: float,
depth_coefficient: float,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000,
dropout_rate=0.,
drop_connect_rate=0.,
batch_norm_momentum=0.99,
batch_norm_epsilon=1e-3,
depth_divisor=8,
min_depth=None,
data_format=None,
default_size=None,
**kwargs):
if data_format is None:
data_format = K.image_data_format()
# if data_format == 'channels_first':
# channel_axis = 1
# else:
# channel_axis = -1
if default_size is None:
default_size = 224
if block_args_list is None:
block_args_list = get_default_block_list()
# count number of strides to compute min size
stride_count = 1
for block_args in block_args_list:
if block_args.strides is not None and block_args.strides[0] > 1:
stride_count += 1
min_size = int(2 ** stride_count)
# Determine proper input shape and default size.
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=min_size,
data_format=data_format,
require_flatten=include_top,
weights=weights)
# Stem part
if input_tensor is None:
inputs = layers.Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
inputs = layers.Input(tensor=input_tensor, shape=input_shape)
else:
inputs = input_tensor
x = inputs
x = layers.Conv2D(
filters=round_filters(32, width_coefficient,
depth_divisor, min_depth),
kernel_size=[3, 3],
strides=[2, 2],
kernel_initializer=EfficientNetConvInitializer(),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization(
axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish()(x)
num_blocks = sum([block_args.num_repeat for block_args in block_args_list])
drop_connect_rate_per_block = drop_connect_rate / float(num_blocks)
# Blocks part
for block_idx, block_args in enumerate(block_args_list):
assert block_args.num_repeat > 0
# Update block input and output filters based on depth multiplier.
block_args.input_filters = round_filters(block_args.input_filters, width_coefficient, depth_divisor, min_depth)
block_args.output_filters = round_filters(block_args.output_filters, width_coefficient, depth_divisor, min_depth)
block_args.num_repeat = round_repeats(block_args.num_repeat, depth_coefficient)
# The first block needs to take care of stride and filter size increase.
x = MBConvBlock(block_args.input_filters, block_args.output_filters,
block_args.kernel_size, block_args.strides,
block_args.expand_ratio, block_args.se_ratio,
block_args.identity_skip, drop_connect_rate_per_block * block_idx,
batch_norm_momentum, batch_norm_epsilon, data_format)(x)
if block_args.num_repeat > 1:
block_args.input_filters = block_args.output_filters
block_args.strides = [1, 1]
for _ in range(block_args.num_repeat - 1):
x = MBConvBlock(block_args.input_filters, block_args.output_filters,
block_args.kernel_size, block_args.strides,
block_args.expand_ratio, block_args.se_ratio,
block_args.identity_skip, drop_connect_rate_per_block * block_idx,
batch_norm_momentum, batch_norm_epsilon, data_format)(x)
# Head part
x = layers.Conv2D(
filters=round_filters(1280, width_coefficient, depth_coefficient, min_depth),
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=EfficientNetConvInitializer(),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization(
axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish()(x)
x = layers.GlobalAveragePooling2D(data_format=data_format)(x)
if dropout_rate > 0:
x = layers.Dropout(dropout_rate)(x)
x = layers.Dense(classes, kernel_initializer=EfficientNetDenseInitializer())(x)
x = layers.Activation('softmax')(x)
outputs = 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)
model = Model(inputs, outputs)
# Load weights
elif weights is not None:
model.load_weights(weights)
def InceptionV31D(input_shape=None,
weights=None,
input_tensor=None,
pooling=None,
classes=2,
dropout=0.0,
top={
'n_neurons': [],
'dropout': [],
'batch_norm': True
}):
"""Instantiates the Inception v3 architecture.
Optionally loads pre-trained weights.
Note that the data format convention used by the model is
the one specified in your Keras cfg_clb at `~/.keras/keras.json`.
# Arguments
input_shape: optional shape tuple, only to be specified
if `top` is None (otherwise the input shape
has to be `(...)` (with `channels_last` data format)
or `(...)` (with `channels_first` data format).
It should have exactly 3 input channel,
and width and height should be no smaller than 75.
E.g. `(150, 1)` would be one valid value.
weights: one of `None` (random initialization)
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.
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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
include_top: whether to include the fully-connected
layer at the top of the network.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
if weights is not None and not os.path.exists(weights):
raise ValueError('The `weights` argument should be either'
'`None` (random initialization),'
'or the path to the weights file to be loaded.')
if input_tensor is None:
inp = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
inp = Input(tensor=input_tensor, shape=input_shape)
else:
inp = input_tensor
if K.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
# Input layer
inp = Input(shape=input_shape)
x = conv1d_bn(inp, 32, 3, strides=2, padding='valid')
x = conv1d_bn(x, 32, 3, padding='valid')
x = conv1d_bn(x, 64, 3)
x = MaxPooling1D(3, strides=2)(x)
x = conv1d_bn(x, 80, 1, padding='valid')
x = conv1d_bn(x, 192, 3, padding='valid')
x = MaxPooling1D(3, strides=2)(x)
# mixed 0: 35 x 35 x 256
x = inception_module(x, 64, 64, 96, 48, 64, 32, double=True, name='mixed0')
# mixed 1: 35 x 35 x 288
x = inception_module(x, 64, 64, 96, 48, 64, 64, double=True, name='mixed1')
# mixed 2: 35 x 35 x 288
x = inception_module(x, 64, 64, 96, 48, 64, 64, double=True, name='mixed2')
# mixed 3: 17 x 17 x 768
conv3 = conv1d_bn(x, 384, 3, strides=2, padding='valid')
conv3dbl = conv1d_bn(x, 64, 1)
conv3dbl = conv1d_bn(conv3dbl, 96, 3)
conv3dbl = conv1d_bn(conv3dbl, 96, 3, strides=2, padding='valid')
pool = MaxPooling1D(3, strides=2)(x)
x = concatenate([conv3, conv3dbl, pool], axis=channel_axis, name='mixed3')
# mixed 4: 17 x 17 x 768
conv1 = conv1d_bn(x, 192, 1)
conv7 = conv1d_bn(x, 128, 1)
conv7 = conv1d_bn(conv7, 128, 7)
conv7dbl = conv1d_bn(x, 128, 1)
conv7dbl = conv1d_bn(conv7dbl, 128, 7)
conv7dbl = conv1d_bn(conv7dbl, 128, 7)
pool = AveragePooling1D(3, strides=1, padding='same')(x)
pool = conv1d_bn(pool, 192, 1)
x = concatenate([conv1, conv7, conv7dbl, pool],
axis=channel_axis,
name='mixed4')
# mixed 5, 6: 17 x 17 x 768
for i in range(2):
conv1 = conv1d_bn(x, 192, 1)
conv7 = conv1d_bn(x, 160, 1)
conv7 = conv1d_bn(conv7, 192, 7)
conv7dbl = conv1d_bn(x, 160, 1)
conv7dbl = conv1d_bn(conv7dbl, 160, 7)
conv7dbl = conv1d_bn(conv7dbl, 192, 7)
pool = AveragePooling1D(3, strides=1, padding='same')(x)
pool = conv1d_bn(pool, 192, 1)
x = concatenate([conv1, conv7, conv7dbl, pool],
axis=channel_axis,
name='mixed' + str(5 + i))
# mixed 7: 17 x 17 x 768
conv1 = conv1d_bn(x, 192, 1)
conv7 = conv1d_bn(x, 192, 1)
conv7 = conv1d_bn(conv7, 192, 7)
conv7dbl = conv1d_bn(x, 192, 1)
conv7dbl = conv1d_bn(conv7dbl, 192, 7)
conv7dbl = conv1d_bn(conv7dbl, 192, 7)
pool = AveragePooling1D(3, strides=1, padding='same')(x)
pool = conv1d_bn(pool, 192, 1)
x = concatenate([conv1, conv7, conv7dbl, pool],
axis=channel_axis,
name='mixed7')
# mixed 8: 8 x 8 x 1280
conv3 = conv1d_bn(x, 192, 1)
conv3 = conv1d_bn(conv3, 320, 3, strides=2, padding='valid')
conv7 = conv1d_bn(x, 192, 1)
conv7 = conv1d_bn(conv7, 192, 7)
conv7 = conv1d_bn(conv7, 192, 3, strides=2, padding='valid')
pool = MaxPooling1D(3, strides=2)(x)
x = concatenate([conv3, conv7, pool], axis=channel_axis, name='mixed8')
# mixed 9: 8 x 8 x 2048
for i in range(2):
conv1 = conv1d_bn(x, 320, 1)
conv3 = conv1d_bn(x, 384, 1)
conv3 = conv1d_bn(conv3, 384, 3)
conv3dbl = conv1d_bn(x, 448, 1)
conv3dbl = conv1d_bn(conv3dbl, 384, 3)
conv3dbl = conv1d_bn(conv3dbl, 384, 3)
pool = AveragePooling1D(3, strides=1, padding='same')(x)
pool = conv1d_bn(pool, 192, 1)
x = concatenate([conv1, conv3, conv3dbl, pool],
axis=channel_axis,
name='mixed' + str(9 + i))
if top is None or top['n_neurons'] is None:
if pooling == 'avg':
x = GlobalAveragePooling1D()(x)
elif pooling == 'max':
x = GlobalMaxPooling1D()(x)
else:
# Include the fully-connected layer(s) at the top of the network
# Classification/prediction block
if classes == 2:
n_pred_neurons = 1
last_activation = 'sigmoid'
else:
n_pred_neurons = classes
last_activation = 'softmax'
dense_layers = list(top['n_neurons'])
dense_layers.append(n_pred_neurons)
x = GlobalAveragePooling1D(name='avg_pool')(x)
if dropout > 0:
x = Dropout(dropout, name='dropout_{}'.format(dropout))(x)
x = dense_block(x,
dense_layers,
flatten=False,
last_activation=last_activation,
batch_norm=top['batch_norm'],
batch_norm_after_activation=True,
dropout=top['dropout'],
name='fc')
# 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 = inp
# Create model
model = Model(inputs, x, name='inceptionV31D')
# Load weights
if weights is not None:
model.load_weights(weights)
# Return Keras model instance
return model
def VGG16_fix(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the VGG16 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`.
# Arguments
include_top: whether to include the 3 fully-connected
layers 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 input channels,
and width and height should be no smaller than 32.
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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
"""
acf = 'relufix'
acfpred = 'softmaxfix'
#backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Block 1
x = layers.Conv2D(64, (3, 3),
activation=acf,
padding='same',
name='block1_conv1')(img_input)
x = layers.Conv2D(64, (3, 3),
activation=acf,
padding='same',
name='block1_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = layers.Conv2D(128, (3, 3),
activation=acf,
padding='same',
name='block2_conv1')(x)
x = layers.Conv2D(128, (3, 3),
activation=acf,
padding='same',
name='block2_conv2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = layers.Conv2D(256, (3, 3),
activation=acf,
padding='same',
name='block3_conv1')(x)
x = layers.Conv2D(256, (3, 3),
activation=acf,
padding='same',
name='block3_conv2')(x)
x = layers.Conv2D(256, (3, 3),
activation=acf,
padding='same',
name='block3_conv3')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = layers.Conv2D(512, (3, 3),
activation=acf,
padding='same',
name='block4_conv1')(x)
x = layers.Conv2D(512, (3, 3),
activation=acf,
padding='same',
name='block4_conv2')(x)
x = layers.Conv2D(512, (3, 3),
activation=acf,
padding='same',
name='block4_conv3')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
# Block 5
x = layers.Conv2D(512, (3, 3),
activation=acf,
padding='same',
name='block5_conv1')(x)
x = layers.Conv2D(512, (3, 3),
activation=acf,
padding='same',
name='block5_conv2')(x)
x = layers.Conv2D(512, (3, 3),
activation=acf,
padding='same',
name='block5_conv3')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
if include_top:
# Classification block
x = layers.Flatten(name='flatten')(x)
x = layers.Dense(4096, activation=acf, name='fc1')(x)
x = layers.Dense(4096, activation=acf, name='fc2')(x)
x = layers.Dense(classes, activation=acfpred, name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='vgg16')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = keras_utils.get_file(
'vgg16_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
file_hash='64373286793e3c8b2b4e3219cbf3544b')
else:
weights_path = keras_utils.get_file(
'vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='6d6bbae143d832006294945121d1f1fc')
model.load_weights(weights_path)
if backend.backend() == 'theano':
keras_utils.convert_all_kernels_in_model(model)
elif weights is not None:
model.load_weights(weights)
return model
def SEResNet(input_shape=None,
initial_conv_filters=64,
depth=[3, 4, 6, 3],
filters=[64, 128, 256, 512],
width=1,
bottleneck=False,
weight_decay=1e-4,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000):
""" Instantiate the Squeeze and Excite ResNet architecture. Note that ,
when using TensorFlow for best performance you should set
`image_data_format="channels_last"` in your Keras config
at ~/.keras/keras.json.
The model are compatible with both
TensorFlow and Theano. The dimension ordering
convention used by the model is the one
specified in your Keras config file.
# Arguments
initial_conv_filters: number of features for the initial convolution
depth: number or layers in the each block, defined as a list.
ResNet-50 = [3, 4, 6, 3]
ResNet-101 = [3, 6, 23, 3]
ResNet-152 = [3, 8, 36, 3]
filter: number of filters per block, defined as a list.
filters = [64, 128, 256, 512
width: width multiplier for the network (for Wide ResNets)
bottleneck: adds a bottleneck conv to reduce computation
weight_decay: weight decay (l2 norm)
include_top: whether to include the fully-connected
layer at the top of the network.
weights: `None` (random initialization) or `imagenet` (trained
on ImageNet)
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 `tf` dim ordering)
or `(3, 224, 224)` (with `th` dim ordering).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 8.
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.
"""
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
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 len(depth) == len(filters), "The length of filter increment list must match the length " \
"of the depth list."
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
data_format=K.image_data_format(),
require_flatten=False)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = _create_se_resnet(classes, img_input, include_top,
initial_conv_filters, filters, depth, width,
bottleneck, weight_decay, pooling)
# pt_features = SEResNet50(input_shape, include_top=False)
bn_features = BatchNormalization()(x)
glb_max = GlobalMaxPooling2D()(bn_features)
gap_dr = Dropout(0.25)(glb_max)
dr_steps = Dropout(0.25)(Dense(512, activation='relu')(gap_dr))
dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps))
dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps))
dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps))
dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps))
output = Dense(5, activation='softmax')(dr_steps)
# 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, output, name='resnext')
# load weights
return model
def DenseNet(blocks,
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the DenseNet 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`.
# Arguments
blocks: numbers of building blocks for the four dense layers.
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 32.
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.
"""
## global backend, layers, models, keras_utils
## backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input)
x = layers.Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x)
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name='conv1/bn')(x)
x = layers.Activation('relu', name='conv1/relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = layers.MaxPooling2D(3, strides=2, name='pool1')(x)
x = dense_block(x, blocks[0], name='conv2')
x = transition_block(x, 0.5, name='pool2')
x = dense_block(x, blocks[1], name='conv3')
x = transition_block(x, 0.5, name='pool3')
x = dense_block(x, blocks[2], name='conv4')
x = transition_block(x, 0.5, name='pool4')
x = dense_block(x, blocks[3], name='conv5')
x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x)
x = layers.Activation('relu', name='relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
if blocks == [6, 12, 24, 16]:
model = models.Model(inputs, x, name='densenet121')
elif blocks == [6, 12, 32, 32]:
model = models.Model(inputs, x, name='densenet169')
elif blocks == [6, 12, 48, 32]:
model = models.Model(inputs, x, name='densenet201')
else:
model = models.Model(inputs, x, name='densenet')
# Load weights.
if weights == 'imagenet':
if include_top:
if blocks == [6, 12, 24, 16]:
weights_path = keras_utils.get_file(
'densenet121_weights_tf_dim_ordering_tf_kernels.h5',
DENSENET121_WEIGHT_PATH,
cache_subdir='models',
file_hash='9d60b8095a5708f2dcce2bca79d332c7')
elif blocks == [6, 12, 32, 32]:
weights_path = keras_utils.get_file(
'densenet169_weights_tf_dim_ordering_tf_kernels.h5',
DENSENET169_WEIGHT_PATH,
cache_subdir='models',
file_hash='d699b8f76981ab1b30698df4c175e90b')
elif blocks == [6, 12, 48, 32]:
weights_path = keras_utils.get_file(
'densenet201_weights_tf_dim_ordering_tf_kernels.h5',
DENSENET201_WEIGHT_PATH,
cache_subdir='models',
file_hash='1ceb130c1ea1b78c3bf6114dbdfd8807')
else:
if blocks == [6, 12, 24, 16]:
weights_path = keras_utils.get_file(
'densenet121_weights_tf_dim_ordering_tf_kernels_notop.h5',
DENSENET121_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='30ee3e1110167f948a6b9946edeeb738')
elif blocks == [6, 12, 32, 32]:
weights_path = keras_utils.get_file(
'densenet169_weights_tf_dim_ordering_tf_kernels_notop.h5',
DENSENET169_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='b8c4d4c20dd625c148057b9ff1c1176b')
elif blocks == [6, 12, 48, 32]:
weights_path = keras_utils.get_file(
'densenet201_weights_tf_dim_ordering_tf_kernels_notop.h5',
DENSENET201_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='c13680b51ded0fb44dff2d8f86ac8bb1')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def ResNet50(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
dataset="cifar10",
**kwargs):
"""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`.
# 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 32.
E.g. `(200, 200, 3)` would be one valid value.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
"""
#global backend, layers, models, keras_utils
#backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
if dataset.casefold() == "cifar10":
classes = 10
elif dataset.casefold() == "isic":
classes = 8
elif dataset.casefold() == "imagenet":
classes = 1000
else:
print("Keras Resnet model: Please specify the name of your dataset")
exit()
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.')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
if dataset.casefold(
) == "cifar10": # input size 32x32, therefore we want a smaller conv kernel:
x = layers.ZeroPadding2D(padding=(1, 1), name='conv1_pad')(img_input)
x = layers.Conv2D(64, (3, 3),
strides=(1, 1),
padding='valid',
kernel_initializer=custom_initialize,
name='conv1')(x)
else:
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer=custom_initialize,
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
#if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
#else:
# if pooling == 'avg':
# x = layers.GlobalAveragePooling2D()(x)
# elif pooling == 'max':
# x = layers.GlobalMaxPooling2D()(x)
# else:
# warnings.warn('The output shape of `ResNet50(include_top=False)` '
# 'has been changed since Keras 2.2.0.')
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='resnet50')
# Load weights.
#if weights == 'imagenet':
# if include_top:
# weights_path = keras_utils.get_file(
# 'resnet50_weights_tf_dim_ordering_tf_kernels.h5',
# WEIGHTS_PATH,
# cache_subdir='models',
# md5_hash='a7b3fe01876f51b976af0dea6bc144eb')
# else:
# weights_path = keras_utils.get_file(
# 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
# WEIGHTS_PATH_NO_TOP,
# cache_subdir='models',
# md5_hash='a268eb855778b3df3c7506639542a6af')
# model.load_weights(weights_path)
# if backend.backend() == 'theano':
# keras_utils.convert_all_kernels_in_model(model)
#elif weights is not None:
# model.load_weights(weights)
return model
def ResNet50(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""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`.
# 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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer='he_normal',
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
else:
warnings.warn('The output shape of `ResNet50(include_top=False)` '
'has been changed since Keras 2.2.0.')
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='resnet50')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = keras_utils.get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
md5_hash='a7b3fe01876f51b976af0dea6bc144eb')
else:
weights_path = keras_utils.get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
model.load_weights(weights_path)
if backend.backend() == 'theano':
keras_utils.convert_all_kernels_in_model(model)
elif weights is not None:
model.load_weights(weights)
return model
def ResNet50(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""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`.
# 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 32.
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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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 input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if backend.image_data_format() == 'channels_last':
bn_axis = 3
else:
bn_axis = 1
x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
x = layers.Conv2D(64, (7, 7),
strides=(2, 2),
padding='valid',
kernel_initializer='he_normal',
name='conv1')(x)
x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = layers.Activation('relu')(x)
x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1))
x = identity_block(x, 3, [64, 64, 256], stage=2, block='b')
x = identity_block(x, 3, [64, 64, 256], stage=2, block='c')
x = conv_block(x, 3, [128, 128, 512], stage=3, block='a')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='c')
x = identity_block(x, 3, [128, 128, 512], stage=3, block='d')
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e')
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f')
x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b')
x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c')
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
else:
warnings.warn('The output shape of `ResNet50(include_top=False)` '
'has been changed since Keras 2.2.0.')
# 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 = models.Model(inputs, x, name='resnet50')
return model
def MobileNet(input_shape=None,
alpha=1.0,
depth_multiplier=1,
dropout=1e-3,
include_top=True,
weights='imagenet',
input_tensor=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the MobileNet architecture.
# Arguments
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 32.
E.g. `(200, 200, 3)` would be one valid value.
alpha: controls the width of the network. This is known as the
width multiplier in the MobileNet paper.
- If `alpha` < 1.0, proportionally decreases the number
of filters in each layer.
- If `alpha` > 1.0, proportionally increases the number
of filters in each layer.
- If `alpha` = 1, default number of filters from the paper
are used at each layer.
depth_multiplier: depth multiplier for depthwise convolution. This
is called the resolution multiplier in the MobileNet paper.
dropout: dropout rate
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.
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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
"""
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')
# Determine proper input shape and default size.
if input_shape is None:
default_size = 224
else:
if backend.image_data_format() == 'channels_first':
rows = input_shape[1]
cols = input_shape[2]
else:
rows = input_shape[0]
cols = input_shape[1]
if rows == cols and rows in [128, 160, 192, 224]:
default_size = rows
else:
default_size = 224
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if backend.image_data_format() == 'channels_last':
row_axis, col_axis = (0, 1)
else:
row_axis, col_axis = (1, 2)
rows = input_shape[row_axis]
cols = input_shape[col_axis]
if weights == 'imagenet':
if depth_multiplier != 1:
raise ValueError('If imagenet weights are being loaded, '
'depth multiplier must be 1')
if alpha not in [0.25, 0.50, 0.75, 1.0]:
raise ValueError('If imagenet weights are being loaded, '
'alpha can be one of'
'`0.25`, `0.50`, `0.75` or `1.0` only.')
if rows != cols or rows not in [128, 160, 192, 224]:
rows = 224
warnings.warn('MobileNet shape is undefined.'
' Weights for input shape '
'(224, 224) will be loaded.')
if backend.image_data_format() != 'channels_last':
warnings.warn('The MobileNet family of models is only available '
'for the input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height).'
' You should set `image_data_format="channels_last"` '
'in your Keras config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
backend.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = _conv_block(img_input, 32, alpha, strides=(2, 2))
x = _depthwise_conv_block(x, 64, alpha, depth_multiplier, block_id=1)
x = _depthwise_conv_block(x,
128,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=2)
x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, block_id=3)
x = _depthwise_conv_block(x,
256,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=4)
x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, block_id=5)
x = _depthwise_conv_block(x,
512,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=6)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=7)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=8)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=9)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=10)
x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=11)
x = _depthwise_conv_block(x,
1024,
alpha,
depth_multiplier,
strides=(2, 2),
block_id=12)
x = _depthwise_conv_block(x, 1024, alpha, depth_multiplier, block_id=13)
if include_top:
if backend.image_data_format() == 'channels_first':
shape = (int(1024 * alpha), 1, 1)
else:
shape = (1, 1, int(1024 * alpha))
x = layers.GlobalAveragePooling2D()(x)
x = layers.Reshape(shape, name='reshape_1')(x)
x = layers.Dropout(dropout, name='dropout')(x)
x = layers.Conv2D(classes, (1, 1), padding='same',
name='conv_preds')(x)
x = layers.Activation('softmax', name='act_softmax')(x)
x = layers.Reshape((classes, ), name='reshape_2')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='mobilenet_%0.2f_%s' % (alpha, rows))
# Load weights.
if weights == 'imagenet':
if backend.image_data_format() == 'channels_first':
raise ValueError('Weights for "channels_first" format '
'are not available.')
if alpha == 1.0:
alpha_text = '1_0'
elif alpha == 0.75:
alpha_text = '7_5'
elif alpha == 0.50:
alpha_text = '5_0'
else:
alpha_text = '2_5'
if include_top:
model_name = 'mobilenet_%s_%d_tf.h5' % (alpha_text, rows)
weight_path = BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weight_path,
cache_subdir='models')
else:
model_name = 'mobilenet_%s_%d_tf_no_top.h5' % (alpha_text, rows)
weight_path = BASE_WEIGHT_PATH + model_name
weights_path = keras_utils.get_file(model_name,
weight_path,
cache_subdir='models')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
if old_data_format:
backend.set_image_data_format(old_data_format)
return model
def ResNet50(input_tensor, input_shape, pooling=None):
"""Instantiates the ResNet50 architecture.
Note that the data format convention used by the model is
the one specified in your Keras config at `~/.keras/keras.json`.
# Arguments
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 32.
E.g. `(200, 200, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction.
- `None` means that the output of the model will be
the 4D tensor output of the
last convolutional block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, and thus
the output of the model will be a 2D tensor.
- `max` means that global max pooling will
be applied.
# Returns
A Keras model instance.
"""
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
# x = ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input)
# x = Conv2D(64, (7, 7),
# strides=(2, 2),
# padding='valid',
# kernel_initializer='he_normal',
# name='conv1')(x)
# x = Activation('relu')(x)
x = _vshifted_conv(img_input, 48, 'conv1a', activate=False)
x = BatchNormalization(axis=bn_axis, name='bn_conv1a')(x)
x = LeakyReLU(0.1)(x)
# x = _vshifted_conv(x, 48, 'conv1b')
# x = BatchNormalization(axis=bn_axis, name='bn_conv1b')(x)
# x = LeakyReLU(0.1)(x)
# x = ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x)
# x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv_block(x, [48, 48, 96], stage=2, block='a')
x = identity_block(x, [48, 48, 96], stage=2, block='b')
x = identity_block(x, [48, 48, 96], stage=2, block='c')
x = conv_block(x, [96, 96, 192], stage=3, block='a')
x = identity_block(x, [96, 96, 192], stage=3, block='b')
x = identity_block(x, [96, 96, 192], stage=3, block='c')
x = identity_block(x, [96, 96, 192], stage=3, block='d')
x = conv_block(x, [96, 96, 192], stage=4, block='a')
x = identity_block(x, [96, 96, 192], stage=4, block='b')
x = identity_block(x, [96, 96, 192], stage=4, block='c')
x = identity_block(x, [96, 96, 192], stage=4, block='d')
x = identity_block(x, [96, 96, 192], stage=4, block='e')
x = identity_block(x, [96, 96, 192], stage=4, block='f')
x = conv_block(x, [192, 192, 384], stage=5, block='a')
x = identity_block(x, [192, 192, 384], stage=5, block='b')
x = identity_block(x, [192, 192, 384], stage=5, block='c')
# final pad and crop for blind spot
x = ZeroPadding2D([[1, 0], [0, 0]])(x)
x = Cropping2D([[0, 1], [0, 0]])(x)
if pooling is not None:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
inputs = utils.get_source_inputs(input_tensor)
# Create model
model = Model(inputs, x, name='resnet50')
return model
def OctaveResNet(layers,
include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
alpha=0.5,
expansion=1,
initial_filters=64,
initial_strides=False,
**kwargs):
""" Instantiates a Octave ResNet architecture.
# Arguments
layers: list of integers defining the depth of the network and
the number of octave conv blocks per level of the
network.
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 32.
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.
alpha: float between [0, 1]. Defines the ratio of filters
allocated to the high frequency and low frequency
branches of the octave conv.
expansion: int/float. Multiplicative factor to increase the
number of filters in each octave block.
initial_filters: number of filters in the first convolution
layer. Determines how many parameters the network will
have.
initial_strides: bool to determine whether to apply a strided
convolution and max pooling before any octave conv
block. Set to True for ImageNet models and False for
CIFAR models.
# Returns
A Keras model instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
` ValueError: If `alpha` is < 0 or > 1.
ValueError: If `layers` is not a list or a tuple
of integers.
"""
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')
if alpha < 0. or alpha > 1.:
raise ValueError('`alpha` must be between 0 and 1. Current alpha = '
'%f' % alpha)
if type(layers) not in [list, tuple]:
raise ValueError(
'`layers` must be a list/tuple of integers. '
'Current layers = ', layers)
# Force convert all layer values to integers
layers = [int(x) for x in layers]
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
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 initial_strides:
initial_strides = (2, 2)
else:
initial_strides = (1, 1)
x = _conv_bn_relu(img_input,
filters=64,
kernel_size=(7, 7),
strides=initial_strides)
if initial_strides:
x = MaxPool2D((3, 3), strides=(2, 2), padding='same')(x)
num_filters = initial_filters
num_blocks = len(layers)
for i in range(num_blocks - 1):
for j in range(layers[i]):
if j == 0:
strides = (2, 2)
downsample_shortcut = True
else:
strides = (1, 1)
downsample_shortcut = False
# first block has no downsample, no shortcut
if i == 0 and j == 0:
first_block = True
strides = (1, 1)
downsample_shortcut = True
else:
first_block = False
x = _octresnet_bottleneck_block(x, num_filters, alpha, strides,
downsample_shortcut, first_block,
expansion)
# double number of filters per block
num_filters *= 2
# final block
for j in range(layers[-1]):
if j == 0:
strides = (2, 2)
x = _octresnet_final_bottleneck_block(x,
num_filters,
alpha,
strides,
downsample_shortcut=True,
expansion=expansion)
else:
strides = (1, 1)
x = _bottleneck_original(x,
num_filters,
strides,
expansion=expansion)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='fc')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = GlobalMaxPooling2D(name='max_pool')(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
model = Model(inputs, x, name='OctaveResNet')
return model
def InceptionV3(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the Inception v3 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`.
# 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 `(299, 299, 3)` (with `channels_last` data format)
or `(3, 299, 299)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 75.
E.g. `(150, 150, 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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
"""
global backend, layers, models, keras_utils
#backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(
input_shape,
default_size=299,
min_size=75,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if backend.image_data_format() == 'channels_first':
channel_axis = 1
else:
channel_axis = 3
x = conv2d_bn(img_input, 32, 3, 3, strides=(2, 2), padding='valid')
x = conv2d_bn(x, 32, 3, 3, padding='valid')
x = conv2d_bn(x, 64, 3, 3)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv2d_bn(x, 80, 1, 1, padding='valid')
x = conv2d_bn(x, 192, 3, 3, padding='valid')
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
# mixed 0: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 32, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed0')
# mixed 1: 35 x 35 x 288
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed1')
# mixed 2: 35 x 35 x 288
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed2')
# mixed 3: 17 x 17 x 768
branch3x3 = conv2d_bn(x, 384, 3, 3, strides=(2, 2), padding='valid')
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(
branch3x3dbl, 96, 3, 3, strides=(2, 2), padding='valid')
branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate(
[branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed3')
# mixed 4: 17 x 17 x 768
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 128, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 128, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 128, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed4')
# mixed 5, 6: 17 x 17 x 768
for i in range(2):
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 160, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 160, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 160, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = layers.AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(5 + i))
# mixed 7: 17 x 17 x 768
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 192, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 192, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed7')
# mixed 8: 8 x 8 x 1280
branch3x3 = conv2d_bn(x, 192, 1, 1)
branch3x3 = conv2d_bn(branch3x3, 320, 3, 3,
strides=(2, 2), padding='valid')
branch7x7x3 = conv2d_bn(x, 192, 1, 1)
branch7x7x3 = conv2d_bn(branch7x7x3, 192, 1, 7)
branch7x7x3 = conv2d_bn(branch7x7x3, 192, 7, 1)
branch7x7x3 = conv2d_bn(
branch7x7x3, 192, 3, 3, strides=(2, 2), padding='valid')
branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate(
[branch3x3, branch7x7x3, branch_pool],
axis=channel_axis,
name='mixed8')
# mixed 9: 8 x 8 x 2048
for i in range(2):
branch1x1 = conv2d_bn(x, 320, 1, 1)
branch3x3 = conv2d_bn(x, 384, 1, 1)
branch3x3_1 = conv2d_bn(branch3x3, 384, 1, 3)
branch3x3_2 = conv2d_bn(branch3x3, 384, 3, 1)
branch3x3 = layers.concatenate(
[branch3x3_1, branch3x3_2],
axis=channel_axis,
name='mixed9_' + str(i))
branch3x3dbl = conv2d_bn(x, 448, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 384, 3, 3)
branch3x3dbl_1 = conv2d_bn(branch3x3dbl, 384, 1, 3)
branch3x3dbl_2 = conv2d_bn(branch3x3dbl, 384, 3, 1)
branch3x3dbl = layers.concatenate(
[branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis)
branch_pool = layers.AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(9 + i))
if include_top:
# Classification block
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='inception_v3')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = keras_utils.get_file(
'inception_v3_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
file_hash='9a0d58056eeedaa3f26cb7ebd46da564')
else:
weights_path = keras_utils.get_file(
'inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='bcbd6486424b2319ff4ef7d526e38f63')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def Xception(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
attention_module=None,
**kwargs):
"""Instantiates the Xception architecture.
Optionally loads weights pre-trained on ImageNet. This model can
only be used with the data format `(width, height, channels)`.
You should set `image_data_format='channels_last'` in your Keras config
located at ~/.keras/keras.json.
Note that the default input image size for this model is 299x299.
# 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 `(299, 299, 3)`.
It should have exactly 3 inputs channels,
and width and height should be no smaller than 71.
E.g. `(150, 150, 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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
"""
# backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
if backend.image_data_format() != 'channels_last':
warnings.warn('The Xception model is only available for the '
'input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" '
'(channels, width, height). '
'You should set `image_data_format="channels_last"` '
'in your Keras '
'config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
backend.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=71,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = layers.Conv2D(32, (3, 3),
strides=(2, 2),
use_bias=False,
name='block1_conv1')(img_input)
x = layers.BatchNormalization(name='block1_conv1_bn')(x)
x = layers.Activation('relu', name='block1_conv1_act')(x)
x = layers.Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x)
x = layers.BatchNormalization(name='block1_conv2_bn')(x)
x = layers.Activation('relu', name='block1_conv2_act')(x)
residual = layers.Conv2D(128, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = layers.BatchNormalization()(residual)
x = layers.SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1')(x)
x = layers.BatchNormalization(name='block2_sepconv1_bn')(x)
x = layers.Activation('relu', name='block2_sepconv2_act')(x)
x = layers.SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2')(x)
x = layers.BatchNormalization(name='block2_sepconv2_bn')(x)
x = layers.MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = layers.add([x, residual])
residual = layers.Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = layers.BatchNormalization()(residual)
x = layers.Activation('relu', name='block3_sepconv1_act')(x)
x = layers.SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv1')(x)
x = layers.BatchNormalization(name='block3_sepconv1_bn')(x)
x = layers.Activation('relu', name='block3_sepconv2_act')(x)
x = layers.SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block3_sepconv2')(x)
x = layers.BatchNormalization(name='block3_sepconv2_bn')(x)
x = layers.MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block3_pool')(x)
x = layers.add([x, residual])
residual = layers.Conv2D(728, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = layers.BatchNormalization()(residual)
x = layers.Activation('relu', name='block4_sepconv1_act')(x)
x = layers.SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv1')(x)
x = layers.BatchNormalization(name='block4_sepconv1_bn')(x)
x = layers.Activation('relu', name='block4_sepconv2_act')(x)
x = layers.SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block4_sepconv2')(x)
x = layers.BatchNormalization(name='block4_sepconv2_bn')(x)
x = layers.MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = layers.Activation('relu', name=prefix + '_sepconv1_act')(x)
x = layers.SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1')(x)
x = layers.BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = layers.Activation('relu', name=prefix + '_sepconv2_act')(x)
x = layers.SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2')(x)
x = layers.BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = layers.Activation('relu', name=prefix + '_sepconv3_act')(x)
x = layers.SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3')(x)
x = layers.BatchNormalization(name=prefix + '_sepconv3_bn')(x)
# attention_module
if attention_module is not None:
x = attach_attention_module(x, attention_module)
x = layers.add([x, residual])
residual = layers.Conv2D(1024, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = layers.BatchNormalization()(residual)
x = layers.Activation('relu', name='block13_sepconv1_act')(x)
x = layers.SeparableConv2D(728, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv1')(x)
x = layers.BatchNormalization(name='block13_sepconv1_bn')(x)
x = layers.Activation('relu', name='block13_sepconv2_act')(x)
x = layers.SeparableConv2D(1024, (3, 3),
padding='same',
use_bias=False,
name='block13_sepconv2')(x)
x = layers.BatchNormalization(name='block13_sepconv2_bn')(x)
x = layers.MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = layers.add([x, residual])
x = layers.SeparableConv2D(1536, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv1')(x)
x = layers.BatchNormalization(name='block14_sepconv1_bn')(x)
x = layers.Activation('relu', name='block14_sepconv1_act')(x)
x = layers.SeparableConv2D(2048, (3, 3),
padding='same',
use_bias=False,
name='block14_sepconv2')(x)
x = layers.BatchNormalization(name='block14_sepconv2_bn')(x)
x = layers.Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='xception')
# Load weights.
if weights == 'imagenet':
if include_top:
weights_path = keras_utils.get_file(
'xception_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models',
file_hash='0a58e3b7378bc2990ea3b43d5981f1f6')
else:
weights_path = keras_utils.get_file(
'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
file_hash='b0042744bf5b25fce3cb969f33bebb97')
model.load_weights(weights_path)
if backend.backend() == 'theano':
keras_utils.convert_all_kernels_in_model(model)
elif weights is not None:
model.load_weights(weights)
if old_data_format:
backend.set_image_data_format(old_data_format)
return model
def EfficientNet(width_coefficient,
depth_coefficient,
default_resolution,
dropout_rate=0.2,
drop_connect_rate=0.2,
depth_divisor=8,
blocks_args=DEFAULT_BLOCKS_ARGS,
model_name='efficientnet',
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
spatial_dropout=False,
**kwargs):
"""Instantiates the EfficientNet architecture using given scaling coefficients.
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`.
# Arguments
width_coefficient: float, scaling coefficient for network width.
depth_coefficient: float, scaling coefficient for network depth.
default_resolution: int, default input image size.
dropout_rate: float, dropout rate before final classifier layer.
drop_connect_rate: float, dropout rate at skip connections.
depth_divisor: int.
blocks_args: A list of BlockArgs to construct block modules.
model_name: string, model name.
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.
It should have exactly 3 inputs channels.
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.
"""
# global backend, layers, models, keras_utils
# backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=default_resolution,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
activation = get_swish(**kwargs)
# Build stem
x = img_input
x = layers.Conv2D(round_filters(32, width_coefficient, depth_divisor),
3,
strides=(2, 2),
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='stem_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name='stem_bn')(x)
x = layers.Activation(activation, name='stem_activation')(x)
# Build blocks
num_blocks_total = sum(block_args.num_repeat for block_args in blocks_args)
block_num = 0
for idx, block_args in enumerate(blocks_args):
assert block_args.num_repeat > 0
# Update block input and output filters based on depth multiplier.
block_args = block_args._replace(
input_filters=round_filters(block_args.input_filters,
width_coefficient, depth_divisor),
output_filters=round_filters(block_args.output_filters,
width_coefficient, depth_divisor),
num_repeat=round_repeats(block_args.num_repeat, depth_coefficient))
# The first block needs to take care of stride and filter size increase.
drop_rate = drop_connect_rate * float(block_num) / num_blocks_total
x = mb_conv_block(x,
block_args,
activation=activation,
drop_rate=drop_rate,
prefix='block{}a_'.format(idx + 1))
block_num += 1
if block_args.num_repeat > 1:
# pylint: disable=protected-access
block_args = block_args._replace(
input_filters=block_args.output_filters, strides=[1, 1])
# pylint: enable=protected-access
for bidx in xrange(block_args.num_repeat - 1):
drop_rate = drop_connect_rate * float(
block_num) / num_blocks_total
block_prefix = 'block{}{}_'.format(
idx + 1, string.ascii_lowercase[bidx + 1])
x = mb_conv_block(x,
block_args,
activation=activation,
drop_rate=drop_rate,
prefix=block_prefix)
block_num += 1
# Build top
x = layers.Conv2D(round_filters(1280, width_coefficient, depth_divisor),
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='top_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name='top_bn')(x)
x = layers.Activation(activation, name='top_activation')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
if dropout_rate and dropout_rate > 0:
x = layers.Dropout(dropout_rate, name='top_dropout')(x)
x = layers.Dense(classes,
activation='softmax',
kernel_initializer=DENSE_KERNEL_INITIALIZER,
name='probs')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name=model_name)
# Load weights.
if weights == 'imagenet':
if include_top:
file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_autoaugment.h5'
file_hash = WEIGHTS_HASHES[model_name][0]
else:
file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5'
file_hash = WEIGHTS_HASHES[model_name][1]
weights_path = keras_utils.get_file(file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir='models',
file_hash=file_hash)
if not spatial_dropout:
print("--------- No Sptial Dropout")
model.load_weights(weights_path)
else:
print("######### Sptial Dropout")
initial_model = EfficientNetB32(
input_tensor=input_tensor,
default_resolution=img_input.shape[1],
weights='imagenet',
include_top=False,
input_shape=(img_input.shape[1], img_input.shape[1], 3))
count = 0
for id, layer in enumerate(initial_model.layers):
print(layer.name, model.layers[count].name)
if "spatial_dropout" in model.layers[count].name:
count += 1
if "transformation" in model.layers[count].name:
count += 1
if layer.name == model.layers[count].name:
print("Igual", layer.name, model.layers[count].name)
if len(layer.get_weights()) == len(
model.layers[count].get_weights()):
try:
model.layers[count].set_weights(
layer.get_weights())
except ValueError:
print("Error jump")
count += 1
elif weights is not None:
model.load_weights(weights)
return model
def InceptionResNetV2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the Inception-ResNet v2 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`.
# 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 `(299, 299, 3)` (with `'channels_last'` data format)
or `(3, 299, 299)` (with `'channels_first'` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 75.
E.g. `(150, 150, 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 block.
- `'avg'` means that global average pooling
will be applied to the output of the
last convolutional block, 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')
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
use_bn = kwargs['batch_n']
# Stem block: 35 x 35 x 192
x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid', use_bn=use_bn)
x = conv2d_bn(x, 32, 3, padding='valid', use_bn=use_bn)
x = conv2d_bn(x, 64, 3, use_bn=use_bn)
x = layers.MaxPooling2D(3, strides=2)(x)
x = conv2d_bn(x, 80, 1, padding='valid', use_bn=use_bn)
x = conv2d_bn(x, 192, 3, padding='valid', use_bn=use_bn)
x = layers.MaxPooling2D(3, strides=2)(x)
# Mixed 5b (Inception-A block): 35 x 35 x 320
branch_0 = conv2d_bn(x, 96, 1, use_bn=use_bn)
branch_1 = conv2d_bn(x, 48, 1, use_bn=use_bn)
branch_1 = conv2d_bn(branch_1, 64, 5, use_bn=use_bn)
branch_2 = conv2d_bn(x, 64, 1, use_bn=use_bn)
branch_2 = conv2d_bn(branch_2, 96, 3, use_bn=use_bn)
branch_2 = conv2d_bn(branch_2, 96, 3, use_bn=use_bn)
branch_pool = layers.AveragePooling2D(3, strides=1, padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, use_bn=use_bn)
branches = [branch_0, branch_1, branch_2, branch_pool]
channel_axis = 1 if backend.image_data_format() == 'channels_first' else 3
x = layers.Concatenate(axis=channel_axis, name='mixed_5b')(branches)
# 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
for block_idx in range(1, 11):
x = inception_resnet_block(x,
scale=0.17,
block_type='block35',
block_idx=block_idx,
use_bn=use_bn)
x = layers.Dropout(0.1)(x, training=kwargs['training'])
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid', use_bn=use_bn)
branch_1 = conv2d_bn(x, 256, 1, use_bn=use_bn)
branch_1 = conv2d_bn(branch_1, 256, 3, use_bn=use_bn)
branch_1 = conv2d_bn(branch_1,
384,
3,
strides=2,
padding='valid',
use_bn=use_bn)
branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
x = layers.Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
for block_idx in range(1, 21):
x = inception_resnet_block(x,
scale=0.1,
block_type='block17',
block_idx=block_idx,
use_bn=use_bn)
x = layers.Dropout(0.2)(x, training=kwargs['training'])
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
branch_0 = conv2d_bn(x, 256, 1, use_bn=use_bn)
branch_0 = conv2d_bn(branch_0,
384,
3,
strides=2,
padding='valid',
use_bn=use_bn)
branch_1 = conv2d_bn(x, 256, 1, use_bn=use_bn)
branch_1 = conv2d_bn(branch_1,
288,
3,
strides=2,
padding='valid',
use_bn=use_bn)
branch_2 = conv2d_bn(x, 256, 1, use_bn=use_bn)
branch_2 = conv2d_bn(branch_2, 288, 3, use_bn=use_bn)
branch_2 = conv2d_bn(branch_2,
320,
3,
strides=2,
padding='valid',
use_bn=use_bn)
branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = layers.Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
for block_idx in range(1, 10):
x = inception_resnet_block(x,
scale=0.2,
block_type='block8',
block_idx=block_idx,
use_bn=use_bn)
x = layers.Dropout(0.3)(x, training=kwargs['training'])
x = inception_resnet_block(x,
scale=1.,
activation=None,
block_type='block8',
block_idx=10,
use_bn=use_bn)
# Final convolution block: 8 x 8 x 1536
x = conv2d_bn(x, 1536, 1, name='conv_7b', use_bn=use_bn)
last_tensor = None
if include_top:
# Classification block
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
last_tensor = x
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
elif 'custom_top' in kwargs and kwargs['custom_top']:
#Create a custom new classification here if needed
x = layers.GlobalAveragePooling2D()(x)
last_tensor = x
x = layers.Dense(512)(x)
x = layers.Activation('relu', name='class1_ac')(x)
x = layers.Dropout(0.3)(x, training=kwargs['training'])
x = layers.Dense(128)(x)
x = layers.Activation('relu', name='class2_ac')(x)
x = layers.Dropout(0.3)(x, training=kwargs['training'])
x = layers.Dense(classes)(x)
x = layers.Activation('softmax')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
last_tensor = x
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='inception_resnet_v2')
# Load weights.
if 'preload' in kwargs and kwargs['preload']:
if weights == 'imagenet':
if include_top:
fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5'
weights_path = keras_utils.get_file(
fname,
BASE_WEIGHT_URL + fname,
cache_subdir='models',
file_hash='e693bd0210a403b3192acc6073ad2e96')
else:
fname = ('inception_resnet_v2_weights_'
'tf_dim_ordering_tf_kernels_notop.h5')
weights_path = keras_utils.get_file(
fname,
BASE_WEIGHT_URL + fname,
cache_subdir='models',
file_hash='d19885ff4a710c122648d3b5c3b684e4')
model.load_weights(weights_path, by_name=True)
elif weights is not None:
model.load_weights(weights, by_name=True)
if 'feature' in kwargs and kwargs['feature']:
return models.Model(inputs,
last_tensor,
name='inception_resnet_features')
else:
return model
def Cladoh(include_top=True,
input_tensor=None,
input_shape=None,
pooling=None,
classes=3):
# include_top to be let as it is
# weights to None for virgin network
# input_tensor to None
# input_shape I think is going to take (244,244,3) as default value
# pooling need more information
# classes is going to be 3 by default
# with tf.name_scope('Pierre') as scope:
# maybe this need to be changed
if input_shape is None:
input_shape = (224, 224, 3)
# input preparation
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# axis definition, it depends of the backend
if backend.image_data_format() == 'channels_first':
axis = 1
else:
axis = 3
# from here is the layers definition
# stem layer
# print('+'*40, 'img_input_shape: ', img_input.shape)
tensor = type0_layer(img_input, name='stem')
# pair of inception and reduction layers:
# inception layer
# three passes
tensor = type1_layer(tensor, 'inception1', axis)
tensor = type1_layer(tensor, 'inception2', axis)
tensor = type1_layer(tensor, 'inception3', axis)
# reduction layer
reduction_layer_width = 3
reduction_layer_rep_by_branch = [1, 3]
reduction_layer_filter_list = [384, 64, 96, 96]
reduction_layer_kernel_shape_list = [(3, 3), (1, 1), (3, 3), (3, 3)]
reduction_layer_strides_list = [(2, 2), (1, 1), (1, 1), (2, 2)]
reduction_layer_padding_list = ['valid', 'same', 'same', 'valid']
tensor = type1_layer(tensor,
'reduction1',
axis,
width=reduction_layer_width,
inner_pooling='max',
rep_by_branch=reduction_layer_rep_by_branch,
filter_list=reduction_layer_filter_list,
kernel_shape_list=reduction_layer_kernel_shape_list,
strides_list=reduction_layer_strides_list,
pooling_time=True,
pooling_padding='valid',
padding_list=reduction_layer_padding_list,
use_cvbn_pooling=False,
pooling_strides=(2, 2))
# TODO: maybe the change of dimension is to abrupt, something with a more
# : nice slope ?
# now last layers, there is an augmentation of dimension from now to
# the output layer
for i in range(2):
"""
augmentation_layer_width = 3
augmentation_layer_rep_by_branch = []
augmentation_layer_filter_list = [384, 64, 96, 96]
augmentation_layer_kernel_shape_list = [(3, 3), (1, 1), (3, 3), (3, 3)]
augmentation_layer_strides_list = [(2, 2), (1, 1), (1, 1), (2, 2)]
augmentation_layer_padding_list = ['valid', 'same', 'same', 'valid']
"""
# TODO: you need to define a type2 layer for this structure
tensor_1x1 = cvbn(tensor, filters=320, kernel_shape=(1, 1))
tensor_3x3 = cvbn(tensor, filters=384, kernel_shape=(1, 1))
tensor_3x3_1 = cvbn(tensor_3x3, filters=384, kernel_shape=(1, 3))
tensor_3x3_2 = cvbn(tensor_3x3, filters=384, kernel_shape=(3, 1))
tensor_3x3 = layers.concatenate([tensor_3x3_1, tensor_3x3_2],
axis=axis,
name='augmentation' + str(i))
tensor_3x3dbl = cvbn(tensor, filters=448, kernel_shape=(1, 1))
tensor_3x3dbl = cvbn(tensor_3x3dbl, filters=384, kernel_shape=(3, 3))
tensor_3x3dbl_1 = cvbn(tensor_3x3dbl, filters=384, kernel_shape=(1, 3))
tensor_3x3dbl_2 = cvbn(tensor_3x3dbl, filters=384, kernel_shape=(3, 1))
tensor_3x3dbl = layers.concatenate([tensor_3x3dbl_1, tensor_3x3dbl_2],
axis=axis)
tensor_pooling = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(tensor)
tensor_pooling = cvbn(tensor_pooling, filters=192, kernel_shape=(1, 1))
tensor = layers.concatenate(
[tensor_1x1, tensor_3x3, tensor_3x3dbl, tensor_pooling],
axis=axis,
name='augmentation2' + str(9 + i))
# from here is the final setup and return
# output layers
if include_top:
# Classification block
tensor = layers.GlobalAveragePooling2D(name='avg_pool')(tensor)
tensor = layers.Dense(classes,
activation='softmax',
name='predictions')(tensor)
else:
if pooling == 'avg':
tensor = layers.GlobalAveragePooling2D()(tensor)
elif pooling == 'max':
tensor = layers.GlobalMaxPooling2D()(tensor)
# print('+'*40, 'tensor_shape: ', tensor.shape)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# model creation and return
model = models.Model(inputs, tensor, name='cladoh')
return model
def InceptionV3(include_top=True,
input_tensor=None,
input_shape=None,
pooling=None,
classes=3,
train_backbone=True,
num_init_filters=8,
**kwargs):
"""Instantiates the Inception v3 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`.
# 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 `(299, 299, 3)` (with `channels_last` data format)
or `(3, 299, 299)` (with `channels_first` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 75.
E.g. `(150, 150, 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 block.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
"""
# global backend, layers, models, keras_utils
# backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
# if input_tensor is None:
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
# if not backend.is_keras_tensor(input_tensor):
# img_input = layers.Input(tensor=input_tensor, shape=input_shape)
# else:
img_input = input_tensor
# if backend.image_data_format() == 'channels_first':
# channel_axis = 1
# else:
channel_axis = 3
x = conv2d_bn(img_input,
num_init_filters,
3,
3,
strides=(2, 2),
padding='valid',
trainable=train_backbone)
x = conv2d_bn(x,
num_init_filters,
3,
3,
padding='valid',
trainable=train_backbone)
x = conv2d_bn(x, num_init_filters * 2, 3, 3)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv2d_bn(x,
int(num_init_filters * 2.5),
1,
1,
padding='valid',
trainable=train_backbone)
x = conv2d_bn(x,
num_init_filters * 6,
3,
3,
padding='valid',
trainable=train_backbone)
x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
# mixed 0: 35 x 35 x 256
branch1x1 = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch5x5 = conv2d_bn(x, int(num_init_filters * 1.5), 1, 1)
branch5x5 = conv2d_bn(branch5x5, num_init_filters * 2, 5, 5)
branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, num_init_filters, 1, 1)
x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed0')
# mixed 1: 35 x 35 x 288
branch1x1 = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch5x5 = conv2d_bn(x, int(num_init_filters * 1.5), 1, 1)
branch5x5 = conv2d_bn(branch5x5, num_init_filters * 2, 5, 5)
branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, num_init_filters * 2, 1, 1)
x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed1')
# mixed 2: 35 x 35 x 288
branch1x1 = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch5x5 = conv2d_bn(x, int(num_init_filters * 1.5), 1, 1)
branch5x5 = conv2d_bn(branch5x5, num_init_filters * 2, 5, 5)
branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, num_init_filters * 2, 1, 1)
x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed2')
# mixed 3: 17 x 17 x 768
branch3x3 = conv2d_bn(x,
num_init_filters * 12,
3,
3,
strides=(2, 2),
padding='valid',
trainable=train_backbone)
branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl,
num_init_filters * 3,
3,
3,
strides=(2, 2),
padding='valid',
trainable=train_backbone)
branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate([branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed3')
# mixed 4: 17 x 17 x 768
branch1x1 = conv2d_bn(x, num_init_filters * 6, 1, 1)
branch7x7 = conv2d_bn(x, num_init_filters * 4, 1, 1)
branch7x7 = conv2d_bn(branch7x7, num_init_filters * 4, 1, 7)
branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 7, 1)
branch7x7dbl = conv2d_bn(x, num_init_filters * 4, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 4, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 4, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 4, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1)
x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed4')
# mixed 5, 6: 17 x 17 x 768
for i in range(2):
branch1x1 = conv2d_bn(x, num_init_filters * 6, 1, 1)
branch7x7 = conv2d_bn(x, num_init_filters * 5, 1, 1)
branch7x7 = conv2d_bn(branch7x7, num_init_filters * 5, 1, 7)
branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 7, 1)
branch7x7dbl = conv2d_bn(x, num_init_filters * 5, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 5, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 5, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 5, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(5 + i))
# mixed 7: 17 x 17 x 768
branch1x1 = conv2d_bn(x, num_init_filters * 6, 1, 1)
branch7x7 = conv2d_bn(x, num_init_filters * 6, 1, 1)
branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 1, 7)
branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 7, 1)
branch7x7dbl = conv2d_bn(x, num_init_filters * 6, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1)
x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed7')
# mixed 8: 8 x 8 x 1280
branch3x3 = conv2d_bn(x, num_init_filters * 6, 1, 1, trainable=True)
branch3x3 = conv2d_bn(branch3x3,
num_init_filters * 10,
3,
3,
strides=(2, 2),
padding='valid',
trainable=True)
branch7x7x3 = conv2d_bn(x, num_init_filters * 6, 1, 1)
branch7x7x3 = conv2d_bn(branch7x7x3, num_init_filters * 6, 1, 7)
branch7x7x3 = conv2d_bn(branch7x7x3, num_init_filters * 6, 7, 1)
branch7x7x3 = conv2d_bn(branch7x7x3,
num_init_filters * 6,
3,
3,
strides=(2, 2),
padding='valid',
trainable=True)
branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate([branch3x3, branch7x7x3, branch_pool],
axis=channel_axis,
name='mixed8')
# mixed 9: 8 x 8 x 2048
for i in range(2):
branch1x1 = conv2d_bn(x, num_init_filters * 10, 1, 1, trainable=True)
branch3x3 = conv2d_bn(x, num_init_filters * 12, 1, 1, trainable=True)
branch3x3_1 = conv2d_bn(branch3x3,
num_init_filters * 12,
1,
3,
trainable=True)
branch3x3_2 = conv2d_bn(branch3x3,
num_init_filters * 12,
3,
1,
trainable=True)
branch3x3 = layers.concatenate([branch3x3_1, branch3x3_2],
axis=channel_axis,
name='mixed9_' + str(i))
branch3x3dbl = conv2d_bn(x,
num_init_filters * 14,
1,
1,
trainable=True)
branch3x3dbl = conv2d_bn(branch3x3dbl,
num_init_filters * 12,
3,
3,
trainable=True)
branch3x3dbl_1 = conv2d_bn(branch3x3dbl,
num_init_filters * 12,
1,
3,
trainable=True)
branch3x3dbl_2 = conv2d_bn(branch3x3dbl,
num_init_filters * 12,
3,
1,
trainable=True)
branch3x3dbl = layers.concatenate([branch3x3dbl_1, branch3x3dbl_2],
axis=channel_axis)
branch_pool = layers.AveragePooling2D((3, 3),
strides=(1, 1),
padding='same')(x)
branch_pool = conv2d_bn(branch_pool,
num_init_filters * 6,
1,
1,
trainable=True)
x = layers.concatenate(
[branch1x1, branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(9 + i))
if include_top:
# Classification block
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
# model = Model(inputs, x, name='inception_v3')
return x
def build(self,
input_shape=(224, 224, 3),
num_classes=1000,
model_type='large',
pooling_type='avg',
include_top=True,
weights=None,
input_tensor=None):
self.model_type = model_type
self.max_exp_lay_num = 14 if self.model_type is 'large' else 10
# ** input layer
# inputs = Input(shape=input_shape)
if input_tensor is None:
inputs = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
inputs = Input(tensor=input_tensor, shape=input_shape)
else:
inputs = input_tensor
# ** feature extraction layers
net = self.__conv2d_block(inputs,
16,
kernel=(3, 3),
strides=(2, 2),
is_use_bias=False,
padding='same',
activation='HS',
model_type=model_type)
self.nlay += 1
if self.model_type == 'large':
config_list = MobileNetV3.LARGE
elif self.model_type == 'small':
config_list = MobileNetV3.SMALL
else:
raise NotImplementedError
for config in config_list:
net = self.__bottleneck_block(net, *config)
# ** final layers
net = self.__conv2d_block(net,
960 if model_type is 'large' else 576,
kernel=(1, 1),
strides=(1, 1),
is_use_bias=False,
padding='same',
activation='HS',
model_type=model_type)
if pooling_type == 'avg':
net = GlobalAveragePooling2D()(net)
elif pooling_type == 'depthwise':
net = self.__global_depthwise_block(net)
else:
raise NotImplementedError
pooled_shape = (1, 1, net._keras_shape[-1])
net = Reshape(pooled_shape)(net)
net = Conv2D(1280 if model_type is 'large' else 1024, (1, 1),
strides=(1, 1),
padding='same',
use_bias=True,
name='conv_2')(net)
net = Activation(self.Hswish, name='conv_2_activation')(net)
if include_top:
net = Conv2D(num_classes, (1, 1),
strides=(1, 1),
padding='same',
use_bias=True,
name='logits')(net)
net = Flatten()(net)
net = Softmax()(net)
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
model = Model(inputs=inputs, outputs=net)
if weights:
model.load_weights(weights)
return model
def ResNet(stack_fn,
preact,
use_bias,
model_name='resnet',
include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
nclass=1000,
**kwargs):
"""Instantiates the ResNet, ResNetV2, and ResNeXt 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`.
# Arguments
stack_fn: a function that returns output tensor for the
stacked residual blocks.
preact: whether to use pre-activation or not
(True for ResNetV2, False for ResNet and ResNeXt).
use_bias: whether to use biases for convolutional layers or not
(True for ResNet and ResNetV2, False for ResNeXt).
model_name: string, model name.
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.
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.
"""
# Determine proper input shape
# input_shape = input_shape
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)),
name='conv1_pad')(img_input)
x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias,
name='conv1_conv')(x)
if preact is False:
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name='conv1_bn')(x)
x = layers.Activation('relu', name='conv1_relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = stack_fn(x)
if preact is True:
x = layers.BatchNormalization(axis=bn_axis,
epsilon=1.001e-5,
name='post_bn')(x)
x = layers.Activation('relu', name='post_relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
x = layers.Dense(nclass, activation='softmax', name='probs')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name=model_name)
# Load weights.
if weights is not None:
model.load_weights(weights)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
return model
def EfficientNet(width_coefficient,
depth_coefficient,
default_size,
dropout_rate=0.2,
drop_connect_rate=0.2,
depth_divisor=8,
activation_fn=swish,
blocks_args=DEFAULT_BLOCKS_ARGS,
model_name='efficientnet',
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the EfficientNet architecture using given scaling coefficients.
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`.
# Arguments
width_coefficient: float, scaling coefficient for network width.
depth_coefficient: float, scaling coefficient for network depth.
default_size: integer, default input image size.
dropout_rate: float, dropout rate before final classifier layer.
drop_connect_rate: float, dropout rate at skip connections.
depth_divisor: integer, a unit of network width.
activation_fn: activation function.
blocks_args: list of dicts, parameters to construct block modules.
model_name: string, model name.
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.
It should have exactly 3 inputs channels.
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.
"""
#global backend, layers, models, keras_utils
#backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=32,
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
img_input = input_tensor
bn_axis = 3 if K.image_data_format() == 'channels_last' else 1
def round_filters(filters, divisor=depth_divisor):
"""Round number of filters based on depth multiplier."""
filters *= width_coefficient
new_filters = max(divisor,
int(filters + divisor / 2) // divisor * divisor)
# Make sure that round down does not go down by more than 10%.
if new_filters < 0.9 * filters:
new_filters += divisor
return int(new_filters)
def round_repeats(repeats):
"""Round number of repeats based on depth multiplier."""
return int(math.ceil(depth_coefficient * repeats))
# Build stem
x = img_input
x = ZeroPadding2D(padding=correct_pad(K, x, 3), name='stem_conv_pad')(x)
x = Conv2D(round_filters(32),
3,
strides=2,
padding='valid',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='stem_conv')(x)
x = BatchNormalization(axis=bn_axis, name='stem_bn')(x)
x = Activation(activation_fn, name='stem_activation')(x)
# Build blocks
from copy import deepcopy
blocks_args = deepcopy(blocks_args)
b = 0
blocks = float(sum(args['repeats'] for args in blocks_args))
for (i, args) in enumerate(blocks_args):
assert args['repeats'] > 0
# Update block input and output filters based on depth multiplier.
args['filters_in'] = round_filters(args['filters_in'])
args['filters_out'] = round_filters(args['filters_out'])
for j in range(round_repeats(args.pop('repeats'))):
# The first block needs to take care of stride and filter size increase.
if j > 0:
args['strides'] = 1
args['filters_in'] = args['filters_out']
x = block(x,
activation_fn,
drop_connect_rate * b / blocks,
name='block{}{}_'.format(i + 1, chr(j + 97)),
**args)
b += 1
# Build top
x = Conv2D(round_filters(1280),
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name='top_conv')(x)
x = BatchNormalization(axis=bn_axis, name='top_bn')(x)
x = Activation(activation_fn, name='top_activation')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
if dropout_rate > 0:
x = Dropout(dropout_rate, name='top_dropout')(x)
x = Dense(classes,
activation='softmax',
kernel_initializer=DENSE_KERNEL_INITIALIZER,
name='probs')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = GlobalMaxPooling2D(name='max_pool')(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=model_name)
# Load weights.
if weights == 'imagenet':
if include_top:
file_suff = '_weights_tf_dim_ordering_tf_kernels_autoaugment.h5'
file_hash = WEIGHTS_HASHES[model_name[-2:]][0]
else:
file_suff = '_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5'
file_hash = WEIGHTS_HASHES[model_name[-2:]][1]
file_name = model_name + file_suff
weights_path = get_file(file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir='models',
file_hash=file_hash)
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def EfficientNet(input_shape,
block_args_list: List[BlockArgs],
width_coefficient: float,
depth_coefficient: float,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000,
dropout_rate=0.,
drop_connect_rate=0.,
batch_norm_momentum=0.99,
batch_norm_epsilon=1e-3,
depth_divisor=8,
min_depth=None,
data_format=None,
default_size=None,
**kwargs):
"""
Builder model for EfficientNets.
# Arguments:
input_shape: Optional shape tuple, the input shape
depends on the configuration, with a minimum
decided by the number of stride 2 operations.
When None is provided, it defaults to 224.
Considered the "Resolution" parameter from
the paper (inherently Resolution coefficient).
block_args_list: Optional List of BlockArgs, each
of which detail the arguments of the MBConvBlock.
If left as None, it defaults to the blocks
from the paper.
width_coefficient: Determines the number of channels
available per layer. Compound Coefficient that
needs to be found using grid search on a base
configuration model.
depth_coefficient: Determines the number of layers
available to the model. Compound Coefficient that
needs to be found using grid search on a base
configuration model.
include_top: Whether to include the fully-connected
layer at the top of the network.
weights: `None` (random initialization) or
`imagenet` (ImageNet weights)
input_tensor: Optional Keras tensor (i.e. output of
`layers.Input()`)
to use as image input for the model.
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.
dropout_rate: Float, percentage of random dropout.
drop_connect_rate: Float, percentage of random droped
connections.
batch_norm_momentum: Float, default batch normalization
momentum. Obtained from the paper.
batch_norm_epsilon: Float, default batch normalization
epsilon. Obtained from the paper.
depth_divisor: Optional. Used when rounding off the coefficient
scaled channels and depth of the layers.
min_depth: Optional. Minimum depth value in order to
avoid blocks with 0 layers.
data_format: "channels_first" or "channels_last". If left
as None, defaults to the value set in ~/.keras.
default_size: Specifies the default image size of the model
# Raises:
- ValueError: If weights are not in 'imagenet' or None.
- ValueError: If weights are 'imagenet' and `classes` is
not 1000.
# Returns:
A Keras Model.
"""
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')
if data_format is None:
data_format = K.image_data_format()
if data_format == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
if default_size is None:
default_size = 224
if block_args_list is None:
block_args_list = get_default_block_list()
# count number of strides to compute min size
stride_count = 1
for block_args in block_args_list:
if block_args.strides is not None and block_args.strides[0] > 1:
stride_count += 1
min_size = int(2**stride_count)
# Determine proper input shape and default size.
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=min_size,
data_format=data_format,
require_flatten=include_top,
weights=weights)
# Stem part
if input_tensor is None:
inputs = layers.Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
inputs = layers.Input(tensor=input_tensor, shape=input_shape)
else:
inputs = input_tensor
x = inputs
x = layers.Conv2D(filters=round_filters(32, width_coefficient,
depth_divisor, min_depth),
kernel_size=[3, 3],
strides=[2, 2],
kernel_initializer=EfficientNetConvInitializer(),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization(axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish()(x)
num_blocks = sum([block_args.num_repeat for block_args in block_args_list])
drop_connect_rate_per_block = drop_connect_rate / float(num_blocks)
# Blocks part
for block_idx, block_args in enumerate(block_args_list):
assert block_args.num_repeat > 0
# Update block input and output filters based on depth multiplier.
block_args.input_filters = round_filters(block_args.input_filters,
width_coefficient,
depth_divisor, min_depth)
block_args.output_filters = round_filters(block_args.output_filters,
width_coefficient,
depth_divisor, min_depth)
block_args.num_repeat = round_repeats(block_args.num_repeat,
depth_coefficient)
# The first block needs to take care of stride and filter size increase.
x = MBConvBlock(block_args.input_filters, block_args.output_filters,
block_args.kernel_size, block_args.strides,
block_args.expand_ratio, block_args.se_ratio,
block_args.identity_skip,
drop_connect_rate_per_block * block_idx,
batch_norm_momentum, batch_norm_epsilon,
data_format)(x)
if block_args.num_repeat > 1:
block_args.input_filters = block_args.output_filters
block_args.strides = [1, 1]
for _ in range(block_args.num_repeat - 1):
x = MBConvBlock(block_args.input_filters,
block_args.output_filters, block_args.kernel_size,
block_args.strides, block_args.expand_ratio,
block_args.se_ratio, block_args.identity_skip,
drop_connect_rate_per_block * block_idx,
batch_norm_momentum, batch_norm_epsilon,
data_format)(x)
# Head part
x = layers.Conv2D(filters=round_filters(1280, width_coefficient,
depth_coefficient, min_depth),
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=EfficientNetConvInitializer(),
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization(axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish()(x)
if include_top:
x = layers.GlobalAveragePooling2D(data_format=data_format)(x)
if dropout_rate > 0:
x = layers.Dropout(dropout_rate)(x)
x = layers.Dense(classes,
kernel_initializer=EfficientNetDenseInitializer())(x)
x = layers.Activation('softmax')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
outputs = 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)
model = Model(inputs, outputs)
# Load weights
if weights == 'imagenet':
if default_size == 224:
if include_top:
weights_path = get_file(
'efficientnet-b0.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b0_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 240:
if include_top:
weights_path = get_file(
'efficientnet-b1.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b1_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 260:
if include_top:
weights_path = get_file(
'efficientnet-b2.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b2_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 300:
if include_top:
weights_path = get_file(
'efficientnet-b3.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b3_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 380:
if include_top:
weights_path = get_file(
'efficientnet-b4.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b4_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 456:
if include_top:
weights_path = get_file(
'efficientnet-b5.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b5_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
# TODO: When weights for efficientnet-b6 and efficientnet-b7 becomes available, uncomment this section and update
# the ValueError message below (line 537: ValueError('ImageNet weights can only be loaded with EfficientNetB0-5'))
# elif default_size == 528:
# if include_top:
# weights_path = get_file(
# 'efficientnet-b6.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6.h5",
# cache_subdir='models')
# else:
# weights_path = get_file(
# 'efficientnet-b6_notop.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6_notop.h5",
# cache_subdir='models')
# model.load_weights(weights_path)
#
# elif default_size == 600:
# if include_top:
# weights_path = get_file(
# 'efficientnet-b7.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7.h5",
# cache_subdir='models')
# else:
# weights_path = get_file(
# 'efficientnet-b7_notop.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7_notop.h5",
# cache_subdir='models')
# model.load_weights(weights_path)
else:
raise ValueError(
'ImageNet weights can only be loaded with EfficientNetB0-5')
elif weights is not None:
model.load_weights(weights)
return model
def InceptionResNetV2R2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the Inception-ResNet v2 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`.
# 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 `(299, 299, 3)` (with `'channels_last'` data format)
or `(3, 299, 299)` (with `'channels_first'` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 75.
E.g. `(150, 150, 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 block.
- `'avg'` means that global average pooling
will be applied to the output of the
last convolutional block, 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.
"""
global backend, layers, models, keras_utils
# backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
from keras import backend, layers, models
from keras import utils as keras_utils
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')
# Determine proper input shape
# input_shape = _obtain_input_shape(
# input_shape,
# default_size=299,
# min_size=75,
# data_format=backend.image_data_format(),
# require_flatten=include_top,
# weights=weights)
input_shape = input_shape #(96, 120, 86, 2)
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Stem block output: 21 x 27 x 19 x 256
x = conv3d_bn(img_input, 48, 3, padding='valid')
x = conv3d_bn(x, 64, 3)
x1 = layers.MaxPooling3D(3, strides=2)(x)
x2 = conv3d_bn(x, 64, 3, 2, padding='valid')
channel_axis = 1 if backend.image_data_format() == 'channels_first' else 4
x = layers.Concatenate(axis=channel_axis)([x1, x2]) #nKernal = 128
x1 = conv3d_bn(x, 64, 1)
x1 = conv3d_bn(x1, 96, 3, padding='valid')
x2 = conv3d_bn(x, 64, 1)
x2 = conv3d_bn(x2, 64, [1, 7, 1])
x2 = conv3d_bn(x2, 64, [1, 1, 7])
x2 = conv3d_bn(x2, 64, [7, 1, 1])
x2 = conv3d_bn(x2, 96, 3, padding='valid')
x = layers.Concatenate(axis=channel_axis)([x1, x2]) #nKernal = 192
x1 = conv3d_bn(x, 128, 3, 2, padding='valid')
x2 = layers.MaxPooling3D(3, strides=2, padding='valid', name='StemEnd')(x)
x = layers.Concatenate(axis=channel_axis)([x1, x2]) #nKernal = 320
# 2x block35 (Inception-ResNet-A block) output: 21 x 27 x 19 x 320
for block_idx in range(1, 3):
x = inception_resnet_block(
x,
scale=0.17,
# scale=0.1, # reduce to 0.1 to avoid instability
block_type='block35',
block_idx=block_idx)
# Mixed 6a (Reduction-A block) output: 10 x 13 x 9 x 640
branch_0 = conv3d_bn(x, 160, 3, strides=2, padding='valid')
branch_1 = conv3d_bn(x, 128, 1)
branch_1 = conv3d_bn(branch_1, 128, 3)
branch_1 = conv3d_bn(branch_1, 160, 3, strides=2, padding='valid')
branch_pool = layers.MaxPooling3D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
channel_axis = 1 if backend.image_data_format() == 'channels_first' else 4
x = layers.Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 4x block17 (Inception-ResNet-B block) output: 10 x 13 x 9 x 640
for block_idx in range(1, 5):
x = inception_resnet_block(x,
scale=0.1,
block_type='block17',
block_idx=block_idx)
# Mixed 7a (Reduction-B block): 4 x 6 x 4 x 1408
branch_0 = conv3d_bn(x, 192, 1)
branch_0 = conv3d_bn(branch_0, 224, 3, strides=2, padding='valid')
branch_1 = conv3d_bn(x, 192, 1)
branch_1 = conv3d_bn(branch_1, 288, 3, strides=2, padding='valid')
branch_2 = conv3d_bn(x, 192, 1)
branch_2 = conv3d_bn(branch_2, 224, 3)
branch_2 = conv3d_bn(branch_2, 256, 3, strides=2, padding='valid')
branch_pool = layers.MaxPooling3D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = layers.Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 2x block8 (Inception-ResNet-C block): 4 x 6 x 4 x 1408
for block_idx in range(1, 2):
x = inception_resnet_block(
x,
scale=0.2,
# scale=0.1, # reduce to 0.1 to avoid instability
block_type='block8',
block_idx=block_idx)
x = inception_resnet_block(x,
scale=1.,
activation=None,
block_type='block8',
block_idx=5)
# Final convolution block: 4 x 6 x 4 x 512
x = conv3d_bn(x, 512, 1, name='conv_7b')
if include_top:
# Classification block
x = layers.GlobalAveragePooling3D(name='avg_pool')(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling3D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling3D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = models.Model(inputs, x, name='inception_resnet_v2_3D')
# Load weights.
if weights == 'imagenet':
if include_top:
fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5'
weights_path = keras_utils.get_file(
fname,
BASE_WEIGHT_URL + fname,
cache_subdir='models',
file_hash='e693bd0210a403b3192acc6073ad2e96')
else:
fname = ('inception_resnet_v2_weights_'
'tf_dim_ordering_tf_kernels_notop.h5')
weights_path = keras_utils.get_file(
fname,
BASE_WEIGHT_URL + fname,
cache_subdir='models',
file_hash='d19885ff4a710c122648d3b5c3b684e4')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def ResNet(stack_fn,
preact,
use_bias,
model_name='resnet',
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
**kwargs):
"""Instantiates the ResNet, ResNetV2, and ResNeXt 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`.
# Arguments
stack_fn: a function that returns output tensor for the
stacked residual blocks.
preact: whether to use pre-activation or not
(True for ResNetV2, False for ResNet and ResNeXt).
use_bias: whether to use biases for convolutional layers or not
(True for ResNet and ResNetV2, False for ResNeXt).
model_name: string, model name.
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.
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.
"""
# global K, layers, models, keras_utils
# K, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=32,
data_format=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
bn_axis = 3 if data_format == 'channels_last' else 1
x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(img_input)
x = Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv')(x)
if preact is False:
x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5,
name='conv1_bn')(x)
x = Activation('relu', name='conv1_relu')(x)
x = ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x)
x = MaxPooling2D(3, strides=2, name='pool1_pool')(x)
x = stack_fn(x)
if preact is True:
x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5,
name='post_bn')(x)
x = Activation('relu', name='post_relu')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='probs')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name=model_name)
# Load weights.
if (weights == 'imagenet') and (model_name in WEIGHTS_HASHES):
if include_top:
file_name = model_name + '_weights_tf_dim_ordering_tf_kernels.h5'
file_hash = WEIGHTS_HASHES[model_name][0]
else:
file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_notop.h5'
file_hash = WEIGHTS_HASHES[model_name][1]
weights_path = keras_utils.get_file(file_name,
BASE_WEIGHTS_PATH + file_name,
cache_subdir='models',
file_hash=file_hash)
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def EfficientNet(input_shape,
block_args_list: List[BlockArgs],
width_coefficient: float,
depth_coefficient: float,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000,
dropout_rate=0.,
drop_connect_rate=0.,
batch_norm_momentum=0.99,
batch_norm_epsilon=1e-3,
depth_divisor=8,
min_depth=None,
data_format=None,
default_size=None,
**kwargs):
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')
if data_format is None:
data_format = K.image_data_format()
if data_format == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
if default_size is None:
default_size = 224
if block_args_list is None:
block_args_list = get_default_block_list()
# count number of strides to compute min size
stride_count = 1
for block_args in block_args_list:
if block_args.strides is not None and block_args.strides[0] > 1:
stride_count += 1
min_size = int(2**stride_count)
# Determine proper input shape and default size.
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=min_size,
data_format=data_format,
require_flatten=include_top,
weights=weights)
# Stem part
if input_tensor is None:
inputs = layers.Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
inputs = layers.Input(tensor=input_tensor, shape=input_shape)
else:
inputs = input_tensor
x = inputs
x = layers.Conv2D(filters=round_filters(32, width_coefficient,
depth_divisor, min_depth),
kernel_size=[3, 3],
strides=[2, 2],
kernel_initializer=EfficientNetConvInitializer(),
padding='same',
use_bias=False)(x)
x = BatchNormalization(True,
axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish(name='swish_0')(x)
num_blocks = sum([block_args.num_repeat for block_args in block_args_list])
drop_connect_rate_per_block = drop_connect_rate / float(num_blocks)
# Blocks part
for block_idx, block_args in enumerate(block_args_list):
assert block_args.num_repeat > 0
# Update block input and output filters based on depth multiplier.
block_args.input_filters = round_filters(block_args.input_filters,
width_coefficient,
depth_divisor, min_depth)
block_args.output_filters = round_filters(block_args.output_filters,
width_coefficient,
depth_divisor, min_depth)
block_args.num_repeat = round_repeats(block_args.num_repeat,
depth_coefficient)
# The first block needs to take care of stride and filter size increase.
x = MBConvBlock(block_args.input_filters, block_args.output_filters,
block_args.kernel_size, block_args.strides,
block_args.expand_ratio, block_args.se_ratio,
block_args.identity_skip,
drop_connect_rate_per_block * block_idx,
str(block_idx) + '_i', batch_norm_momentum,
batch_norm_epsilon, data_format)(x)
if block_args.num_repeat > 1:
block_args.input_filters = block_args.output_filters
block_args.strides = [1, 1]
for _ in range(block_args.num_repeat - 1):
x = MBConvBlock(block_args.input_filters,
block_args.output_filters, block_args.kernel_size,
block_args.strides, block_args.expand_ratio,
block_args.se_ratio, block_args.identity_skip,
drop_connect_rate_per_block * block_idx,
str(block_idx) + '_' + str(_), batch_norm_momentum,
batch_norm_epsilon, data_format)(x)
# Head part
x = layers.Conv2D(filters=round_filters(1280, width_coefficient,
depth_coefficient, min_depth),
kernel_size=[1, 1],
strides=[1, 1],
kernel_initializer=EfficientNetConvInitializer(),
padding='same',
use_bias=False)(x)
x = BatchNormalization(True,
axis=channel_axis,
momentum=batch_norm_momentum,
epsilon=batch_norm_epsilon)(x)
x = Swish(name='swish_last')(x)
if include_top:
x = layers.GlobalAveragePooling2D(data_format=data_format)(x)
if dropout_rate > 0:
x = layers.Dropout(dropout_rate)(x)
x = layers.Dense(classes,
kernel_initializer=EfficientNetDenseInitializer())(x)
x = layers.Activation('softmax')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
outputs = 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)
model = Model(inputs, outputs)
# Load weights
if weights == 'imagenet':
if default_size == 224:
if include_top:
weights_path = get_file(
'efficientnet-b0.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b0_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 240:
if include_top:
weights_path = get_file(
'efficientnet-b1.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b1_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 260:
if include_top:
weights_path = get_file(
'efficientnet-b2.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b2_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 300:
if include_top:
weights_path = get_file(
'efficientnet-b3.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b3_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 380:
if include_top:
weights_path = get_file(
'efficientnet-b4.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b4_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
elif default_size == 456:
if include_top:
weights_path = get_file(
'efficientnet-b5.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5.h5",
cache_subdir='models')
else:
weights_path = get_file(
'efficientnet-b5_notop.h5',
"https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5_notop.h5",
cache_subdir='models')
model.load_weights(weights_path)
# elif default_size == 528:
# if include_top:
# weights_path = get_file(
# 'efficientnet-b6.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6.h5",
# cache_subdir='models')
# else:
# weights_path = get_file(
# 'efficientnet-b6_notop.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6_notop.h5",
# cache_subdir='models')
# model.load_weights(weights_path)
#
# elif default_size == 600:
# if include_top:
# weights_path = get_file(
# 'efficientnet-b7.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7.h5",
# cache_subdir='models')
# else:
# weights_path = get_file(
# 'efficientnet-b7_notop.h5',
# "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7_notop.h5",
# cache_subdir='models')
# model.load_weights(weights_path)
else:
raise ValueError(
'ImageNet weights can only be loaded with EfficientNetB0-7')
elif weights is not None:
model.load_weights(weights)
return model
