def __transition_block(ip,
nb_filter,
compression=1.0,
weight_decay=1e-4,
attention_module=None):
''' Apply BatchNorm, Relu 1x1, Conv2D, optional compression, dropout and Maxpooling2D
Args:
ip: keras tensor
nb_filter: number of filters
compression: calculated as 1 - reduction. Reduces the number of feature maps
in the transition block.
dropout_rate: dropout rate
weight_decay: weight decay factor
Returns: keras tensor, after applying batch_norm, relu-conv, dropout, maxpool
'''
concat_axis = 1 if K.image_data_format() == 'channels_first' else -1
x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(ip)
x = Activation('relu')(x)
x = Conv2D(int(nb_filter * compression), (1, 1),
kernel_initializer='he_normal',
padding='same',
use_bias=False,
kernel_regularizer=l2(weight_decay))(x)
x = AveragePooling2D((2, 2), strides=(2, 2))(x)
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
return x
def block35(net,
scale=1.0,
activation_fn=tf.nn.relu,
scope=None,
reuse=None,
attention_module=None):
with tf.variable_scope(scope, 'Block35', [net], reuse=reuse):
with tf.variable_scope('Branch_0'):
tower_conv = slim.conv2d(net, 32, 1, scope='Conv2d_1x1')
with tf.variable_scope('Branch_1'):
tower_conv1_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
tower_conv1_1 = slim.conv2d(tower_conv1_0,
32,
3,
scope='Conv2d_0b_3x3')
with tf.variable_scope('Branch_2'):
tower_conv2_0 = slim.conv2d(net, 32, 1, scope='Conv2d_0a_1x1')
tower_conv2_1 = slim.conv2d(tower_conv2_0,
48,
3,
scope='Conv2d_0b_3x3')
tower_conv2_2 = slim.conv2d(tower_conv2_1,
64,
3,
scope='Conv2d_0c_3x3')
mixed = tf.concat(axis=3,
values=[tower_conv, tower_conv1_1, tower_conv2_2])
up = slim.conv2d(mixed,
net.get_shape()[3],
1,
normalizer_fn=None,
activation_fn=None,
scope='Conv2d_1x1')
scaled_up = up * scale
if activation_fn == tf.nn.relu6:
scaled_up = tf.clip_by_value(scaled_up, -6.0, 6.0)
if attention_module == 'se_block':
scaled_up = se_block(scaled_up, 'se_block')
net += scaled_up
if activation_fn:
net = activation_fn(net)
return net
def __dense_block(x,
nb_layers,
nb_filter,
growth_rate,
bottleneck=False,
dropout_rate=None,
weight_decay=1e-4,
grow_nb_filters=True,
return_concat_list=False,
attention_module=None):
''' Build a dense_block where the output of each conv_block is fed to subsequent ones
Args:
x: keras tensor
nb_layers: the number of layers of conv_block to append to the model.
nb_filter: number of filters
growth_rate: growth rate
bottleneck: bottleneck block
dropout_rate: dropout rate
weight_decay: weight decay factor
grow_nb_filters: flag to decide to allow number of filters to grow
return_concat_list: return the list of feature maps along with the actual output
Returns: keras tensor with nb_layers of conv_block appended
'''
concat_axis = 1 if K.image_data_format() == 'channels_first' else -1
x_list = [x]
for i in range(nb_layers):
cb = __conv_block(x, growth_rate, bottleneck, dropout_rate,
weight_decay)
x_list.append(cb)
x = concatenate([x, cb], axis=concat_axis)
if grow_nb_filters:
nb_filter += growth_rate
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
if return_concat_list:
return x, nb_filter, x_list
else:
return x, nb_filter
def __bottleneck_block(input,
filters=64,
cardinality=8,
strides=1,
weight_decay=5e-4,
attention_module=None):
''' Adds a bottleneck block
Args:
input: input tensor
filters: number of output filters
cardinality: cardinality factor described number of
grouped convolutions
strides: performs strided convolution for downsampling if > 1
weight_decay: weight decay factor
Returns: a keras tensor
'''
init = input
grouped_channels = int(filters / cardinality)
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
# Check if input number of filters is same as 16 * k, else create convolution2d for this input
if K.image_data_format() == 'channels_first':
if init._keras_shape[1] != 2 * filters:
init = Conv2D(filters * 2, (1, 1),
padding='same',
strides=(strides, strides),
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(init)
init = BatchNormalization(axis=channel_axis)(init)
else:
if init._keras_shape[-1] != 2 * filters:
init = Conv2D(filters * 2, (1, 1),
padding='same',
strides=(strides, strides),
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(init)
init = BatchNormalization(axis=channel_axis)(init)
x = Conv2D(filters, (1, 1),
padding='same',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(input)
x = BatchNormalization(axis=channel_axis)(x)
x = LeakyReLU()(x)
x = __grouped_convolution_block(x, grouped_channels, cardinality, strides,
weight_decay)
x = Conv2D(filters * 2, (1, 1),
padding='same',
use_bias=False,
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(axis=channel_axis)(x)
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
x = add([init, x])
x = LeakyReLU()(x)
return x
def resnet_v2(input_shape, depth, num_classes=10, attention_module=None):
"""ResNet Version 2 Model builder [b]
Stacks of (1 x 1)-(3 x 3)-(1 x 1) BN-ReLU-Conv2D or also known as
bottleneck layer
First shortcut connection per layer is 1 x 1 Conv2D.
Second and onwards shortcut connection is identity.
At the beginning of each stage, the feature map size is halved (downsampled)
by a convolutional layer with strides=2, while the number of filter maps is
doubled. Within each stage, the layers have the same number filters and the
same filter map sizes.
Features maps sizes:
conv1 : 32x32, 16
stage 0: 32x32, 64
stage 1: 16x16, 128
stage 2: 8x8, 256
# Arguments
input_shape (tensor): shape of input image tensor
depth (int): number of core convolutional layers
num_classes (int): number of classes (CIFAR10 has 10)
# Returns
model (Model): Keras model instance
"""
if (depth - 2) % 9 != 0:
raise ValueError('depth should be 9n+2 (eg 56 or 110 in [b])')
# Start model definition.
num_filters_in = 16
num_res_blocks = int((depth - 2) / 9)
inputs = Input(shape=input_shape)
# v2 performs Conv2D with BN-ReLU on input before splitting into 2 paths
x = resnet_layer(inputs=inputs,
num_filters=num_filters_in,
conv_first=True)
# Instantiate the stack of residual units
for stage in range(3):
for res_block in range(num_res_blocks):
activation = 'relu'
batch_normalization = True
strides = 1
if stage == 0:
num_filters_out = num_filters_in * 4
if res_block == 0: # first layer and first stage
activation = None
batch_normalization = False
else:
num_filters_out = num_filters_in * 2
if res_block == 0: # first layer but not first stage
strides = 2 # downsample
# bottleneck residual unit
y = resnet_layer(inputs=x,
num_filters=num_filters_in,
kernel_size=1,
strides=strides,
activation=activation,
batch_normalization=batch_normalization,
conv_first=False)
y = resnet_layer(inputs=y,
num_filters=num_filters_in,
conv_first=False)
y = resnet_layer(inputs=y,
num_filters=num_filters_out,
kernel_size=1,
conv_first=False)
if res_block == 0:
# linear projection residual shortcut connection to match
# changed dims
x = resnet_layer(inputs=x,
num_filters=num_filters_out,
kernel_size=1,
strides=strides,
activation=None,
batch_normalization=False)
if attention_module == 'se_block':
y = se_block(y)
if attention_module == 'cbam_block':
y = cbam_block(y)
x = keras.layers.add([x, y])
num_filters_in = num_filters_out
# Add classifier on top.
# v2 has BN-ReLU before Pooling
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = AveragePooling2D(pool_size=8)(x)
y = Flatten()(x)
outputs = Dense(num_classes,
activation='softmax',
kernel_initializer='he_normal')(y)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
def inception_resnet_block(x, scale, block_type, block_idx, activation='relu', attention_module=None):
"""Adds a Inception-ResNet block with Squeeze and Excitation block at the end.
This function builds 3 types of Inception-ResNet blocks mentioned
in the paper, controlled by the `block_type` argument (which is the
block name used in the official TF-slim implementation):
- Inception-ResNet-A: `block_type='block35'`
- Inception-ResNet-B: `block_type='block17'`
- Inception-ResNet-C: `block_type='block8'`
# Arguments
x: input tensor.
scale: scaling factor to scale the residuals (i.e., the output of
passing `x` through an inception module) before adding them
to the shortcut branch. Let `r` be the output from the residual branch,
the output of this block will be `x + scale * r`.
block_type: `'block35'`, `'block17'` or `'block8'`, determines
the network structure in the residual branch.
block_idx: an `int` used for generating layer names. The Inception-ResNet blocks
are repeated many times in this network. We use `block_idx` to identify
each of the repetitions. For example, the first Inception-ResNet-A block
will have `block_type='block35', block_idx=0`, ane the layer names will have
a common prefix `'block35_0'`.
activation: activation function to use at the end of the block
(see [activations](../activations.md)).
When `activation=None`, no activation is applied
(i.e., "linear" activation: `a(x) = x`).
# Returns
Output tensor for the block.
# Raises
ValueError: if `block_type` is not one of `'block35'`,
`'block17'` or `'block8'`.
"""
if block_type == 'block35':
branch_0 = conv2d_bn(x, 32, 1)
branch_1 = conv2d_bn(x, 32, 1)
branch_1 = conv2d_bn(branch_1, 32, 3)
branch_2 = conv2d_bn(x, 32, 1)
branch_2 = conv2d_bn(branch_2, 48, 3)
branch_2 = conv2d_bn(branch_2, 64, 3)
branches = [branch_0, branch_1, branch_2]
elif block_type == 'block17':
branch_0 = conv2d_bn(x, 192, 1)
branch_1 = conv2d_bn(x, 128, 1)
branch_1 = conv2d_bn(branch_1, 160, [1, 7])
branch_1 = conv2d_bn(branch_1, 192, [7, 1])
branches = [branch_0, branch_1]
elif block_type == 'block8':
branch_0 = conv2d_bn(x, 192, 1)
branch_1 = conv2d_bn(x, 192, 1)
branch_1 = conv2d_bn(branch_1, 224, [1, 3])
branch_1 = conv2d_bn(branch_1, 256, [3, 1])
branches = [branch_0, branch_1]
else:
raise ValueError('Unknown Inception-ResNet block type. '
'Expects "block35", "block17" or "block8", '
'but got: ' + str(block_type))
block_name = block_type + '_' + str(block_idx)
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
mixed = Concatenate(axis=channel_axis, name=block_name + '_mixed')(branches)
up = conv2d_bn(mixed,
K.int_shape(x)[channel_axis],
1,
activation=None,
use_bias=True,
name=block_name + '_conv')
x = Lambda(lambda inputs, scale: inputs[0] + inputs[1] * scale,
output_shape=K.int_shape(x)[1:],
arguments={'scale': scale},
name=block_name)([x, up])
if activation is not None:
x = Activation(activation, name=block_name + '_ac')(x)
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
return x
def InceptionV3(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000,
attention_module=None):
"""Instantiates the Squeeze and Excite Inception v3 architecture.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or "imagenet" (pre-training 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 `(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 139.
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 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 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')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=139,
data_format=K.image_data_format(),
require_flatten=include_top)
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_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 = 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 = MaxPooling2D((3, 3), strides=(2, 2))(x)
# mixed 0, 1, 2: 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 = 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')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# mixed 1: 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 = 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')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# mixed 2: 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 = 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')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# 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 = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate([branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed3')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# 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 = 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')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# 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 = 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))
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# 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 = 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')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# 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 = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate([branch3x3, branch7x7x3, branch_pool],
axis=channel_axis,
name='mixed8')
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
# 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 = 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))
# attention_module
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
if include_top:
# Classification block
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
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`.
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
model = Model(inputs, x, name='inception_v3')
return model
def _depthwise_conv_block(inputs,
pointwise_conv_filters,
alpha,
depth_multiplier=1,
strides=(1, 1),
block_id=1,
attention_module=None):
"""Adds a depthwise convolution block.
A depthwise convolution block consists of a depthwise conv,
batch normalization, relu6, pointwise convolution,
batch normalization and relu6 activation.
# Arguments
inputs: Input tensor of shape `(rows, cols, channels)`
(with `channels_last` data format) or
(channels, rows, cols) (with `channels_first` data format).
pointwise_conv_filters: Integer, the dimensionality of the output space
(i.e. the number output of filters in the pointwise convolution).
alpha: controls the width of the network.
- 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: The number of depthwise convolution output channels
for each input channel.
The total number of depthwise convolution output
channels will be equal to `filters_in * depth_multiplier`.
strides: An integer or tuple/list of 2 integers,
specifying the strides of the convolution along the width and height.
Can be a single integer to specify the same value for
all spatial dimensions.
Specifying any stride value != 1 is incompatible with specifying
any `dilation_rate` value != 1.
block_id: Integer, a unique identification designating the block number.
# Input shape
4D tensor with shape:
`(batch, channels, rows, cols)` if data_format='channels_first'
or 4D tensor with shape:
`(batch, rows, cols, channels)` if data_format='channels_last'.
# Output shape
4D tensor with shape:
`(batch, filters, new_rows, new_cols)` if data_format='channels_first'
or 4D tensor with shape:
`(batch, new_rows, new_cols, filters)` if data_format='channels_last'.
`rows` and `cols` values might have changed due to stride.
# Returns
Output tensor of block.
"""
channel_axis = 1 if K.image_data_format() == 'channels_first' else -1
pointwise_conv_filters = int(pointwise_conv_filters * alpha)
x = DepthwiseConv2D((3, 3),
padding='same',
depth_multiplier=depth_multiplier,
strides=strides,
use_bias=False,
name='conv_dw_%d' % block_id)(inputs)
x = BatchNormalization(axis=channel_axis,
name='conv_dw_%d_bn' % block_id)(x)
x = Activation(relu6, name='conv_dw_%d_relu' % block_id)(x)
x = Conv2D(pointwise_conv_filters, (1, 1),
padding='same',
use_bias=False,
strides=(1, 1),
name='conv_pw_%d' % block_id)(x)
x = BatchNormalization(axis=channel_axis,
name='conv_pw_%d_bn' % block_id)(x)
x = Activation(relu6, name='conv_pw_%d_relu' % block_id)(x)
if attention_module == 'se_block':
x = se_block(x)
if attention_module == 'cbam_block':
x = cbam_block(x)
return x
def resnet_v1(input_shape, depth, num_classes=10, attention_module=None):
"""ResNet Version 1 Model builder [a]
Stacks of 2 x (3 x 3) Conv2D-BN-ReLU
Last ReLU is after the shortcut connection.
At the beginning of each stage, the feature map size is halved (downsampled)
by a convolutional layer with strides=2, while the number of filters is
doubled. Within each stage, the layers have the same number filters and the
same number of filters.
Features maps sizes:
stage 0: 32x32, 16
stage 1: 16x16, 32
stage 2: 8x8, 64
The Number of parameters is approx the same as Table 6 of [a]:
ResNet20 0.27M
ResNet32 0.46M
ResNet44 0.66M
ResNet56 0.85M
ResNet110 1.7M
# Arguments
input_shape (tensor): shape of input image tensor
depth (int): number of core convolutional layers
num_classes (int): number of classes (CIFAR10 has 10)
# Returns
model (Model): Keras model instance
"""
if (depth - 2) % 6 != 0:
raise ValueError('depth should be 6n+2 (eg 20, 32, 44 in [a])')
# Start model definition.
num_filters = 16
num_res_blocks = int((depth - 2) / 6)
inputs = Input(shape=input_shape)
x = resnet_layer(inputs=inputs)
# Instantiate the stack of residual units
for stack in range(3):
for res_block in range(num_res_blocks):
strides = 1
if stack > 0 and res_block == 0: # first layer but not first stack
strides = 2 # downsample
y = resnet_layer(inputs=x,
num_filters=num_filters,
strides=strides)
y = resnet_layer(inputs=y,
num_filters=num_filters,
activation=None)
if stack > 0 and res_block == 0: # first layer but not first stack
# linear projection residual shortcut connection to match
# changed dims
x = resnet_layer(inputs=x,
num_filters=num_filters,
kernel_size=1,
strides=strides,
activation=None,
batch_normalization=False)
if attention_module == 'se_block':
y = se_block(y)
if attention_module == 'cbam_block':
y = cbam_block(y)
x = keras.layers.add([x, y])
x = Activation('relu')(x)
num_filters *= 2
# Add classifier on top.
# v1 does not use BN after last shortcut connection-ReLU
x = AveragePooling2D(pool_size=8)(x)
y = Flatten()(x)
outputs = Dense(num_classes,
activation='softmax',
kernel_initializer='he_normal')(y)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model