def inception_C(input):
'''Architecture of Inception_C block which is a 8 * 8 grid module.'''
c1 = AveragePooling2D((3, 3), strides = (1, 1), padding = "same")(input)
c1 = conv_block(c1, 256, 1, 1)
c2 = conv_block(input, 256, 1, 1)
c3 = conv_block(input, 384, 1, 1)
c31 = conv_block(c2, 256, 1, 3)
c32 = conv_block(c2, 256, 3, 1)
c3 = concatenate([c31, c32], axis = -1)
# squeeze and excite block
c3 = squeeze_excite_block(c3)
c4 = conv_block(input, 384, 1, 1)
c4 = conv_block(c3, 448, 3, 1)
c4 = conv_block(c3, 512, 1, 3)
c41 = conv_block(c3, 256, 1, 3)
c42 = conv_block(c3, 256, 3, 1)
c4 = concatenate([c41, c42], axis = -1)
merged = concatenate([c1, c2, c3, c4], axis = -1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
return merged
def stem(input):
'''The stem of the pure Inception-v4 and Inception-ResNet-v2 networks. This is input part of those networks.'''
# Input shape is 299 * 299 * 3 (Tensorflow dimension ordering)
x = conv_block(input, 32, 3, 3, strides = (2, 2), padding = "same") # 149 * 149 * 32
x = conv_block(x, 32, 3, 3, padding = "same") # 147 * 147 * 32
x = conv_block(x, 64, 3, 3) # 147 * 147 * 64
x1 = MaxPooling2D((3, 3), strides = (2, 2), padding = "same")(x)
x2 = conv_block(x, 96, 3, 3, strides = (2, 2), padding = "same")
x = concatenate([x1, x2], axis = -1) # 73 * 73 * 160
# squeeze and excite block
x = squeeze_excite_block(x)
x1 = conv_block(x, 64, 1, 1)
x1 = conv_block(x1, 96, 3, 3, padding = "same")
x2 = conv_block(x, 64, 1, 1)
x2 = conv_block(x2, 64, 1, 7)
x2 = conv_block(x2, 64, 7, 1)
x2 = conv_block(x2, 96, 3, 3, padding = "same")
x = concatenate([x1, x2], axis = -1) # 71 * 71 * 192
# squeeze and excite block
x = squeeze_excite_block(x)
x1 = conv_block(x, 192, 3, 3, strides = (2, 2), padding = "same")
x2 = MaxPooling2D((3, 3), strides = (2, 2), padding = "same")(x)
x = concatenate([x1, x2], axis = -1) # 35 * 35 * 384
# squeeze and excite block
x = squeeze_excite_block(x)
return x
def reduction_A(input, k = 192, l = 224, m = 256, n = 384):
'''Architecture of a 35 * 35 to 17 * 17 Reduction_A block.'''
ra1 = MaxPooling2D((3, 3), strides = (2, 2), padding = "same")(input)
ra2 = conv_block(input, n, 3, 3, strides = (2, 2), padding = "same")
ra3 = conv_block(input, k, 1, 1)
ra3 = conv_block(ra3, l, 3, 3)
ra3 = conv_block(ra3, m, 3, 3, strides = (2, 2), padding = "same")
merged = concatenate([ra1, ra2, ra3], axis = -1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
return merged
def get_model(weights='imagenet'):
# create the base pre-trained model
base_model = InceptionResNetV2(weights=weights, include_top=False)
# add a global spatial average pooling layer
x = base_model.output
# x = GlobalAveragePooling2D()(x)
x = squeeze_excite_block(x)
x = GlobalAveragePooling2D()(x)
# x = VLAD(64)(x)
# x = Dropout(0.5)(x)
# let's add a fully-connected layer
# x = Dense(5012, activation='relu')(x)
# and a logistic layer
predictions = Dense(4934, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
return model
def reduction_B(input):
'''Architecture of a 17 * 17 to 8 * 8 Reduction_B block.'''
rb1 = MaxPooling2D((3, 3), strides = (2, 2), padding = "same")(input)
rb2 = conv_block(input, 192, 1, 1)
rb2 = conv_block(rb2, 192, 3, 3, strides = (2, 2), padding = "same")
rb3 = conv_block(input, 256, 1, 1)
rb3 = conv_block(rb3, 256, 1, 7)
rb3 = conv_block(rb3, 320, 7, 1)
rb3 = conv_block(rb3, 320, 3, 3, strides = (2, 2), padding = "same")
merged = concatenate([rb1, rb2, rb3], axis = -1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
return merged
def se_reduction_resnet_A(input, k=192, l=224, m=256, n=384):
'''Architecture of a 35 * 35 to 17 * 17 Reduction_ResNet_A block. It is used by both v1 and v2 Inception-ResNets.'''
rar1 = MaxPooling2D((3, 3), strides=(2, 2))(input)
rar2 = Conv2D(n, (3, 3), activation="relu", strides=(2, 2))(input)
rar3 = Conv2D(k, (1, 1), activation="relu", padding="same")(input)
rar3 = Conv2D(l, (3, 3), activation="relu", padding="same")(rar3)
rar3 = Conv2D(m, (3, 3), activation="relu", strides=(2, 2))(rar3)
merged = concatenate([rar1, rar2, rar3], axis=-1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
rar = BatchNormalization(axis=-1)(merged)
rar = Activation("relu")(rar)
return rar
def inception_A(input):
'''Architecture of Inception_A block which is a 35 * 35 grid module.'''
a1 = AveragePooling2D((3, 3), strides = (1, 1), padding = "same")(input)
a1 = conv_block(a1, 96, 1, 1)
a2 = conv_block(input, 96, 1, 1)
a3 = conv_block(input, 64, 1, 1)
a3 = conv_block(a3, 96, 3, 3)
a4 = conv_block(input, 64, 1, 1)
a4 = conv_block(a4, 96, 3, 3)
a4 = conv_block(a4, 96, 3, 3)
merged = concatenate([a1, a2, a3, a4], axis = -1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
return merged
def se_inception_resnet_v1_C(input, scale_residual=True):
'''Architecture of Inception_ResNet_C block which is a 8 * 8 grid module.'''
cr1 = Conv2D(192, (1, 1), activation="relu", padding="same")(input)
cr2 = Conv2D(192, (1, 1), activation="relu", padding="same")(input)
cr2 = Conv2D(192, (1, 3), activation="relu", padding="same")(cr2)
cr2 = Conv2D(192, (3, 1), activation="relu", padding="same")(cr2)
merged = concatenate([cr1, cr2], axis=-1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
cr = Conv2D(1792, (1, 1), activation="linear", padding="same")(merged)
if scale_residual: cr = Lambda(lambda c: c * 0.1)(cr)
output = add([input, cr])
output = BatchNormalization(axis=-1)(output)
output = Activation("relu")(output)
return output
def se_inception_resnet_v1_B(input, scale_residual=True):
'''Architecture of Inception_ResNet_B block which is a 17 * 17 grid module.'''
br1 = Conv2D(128, (1, 1), activation="relu", padding="same")(input)
br2 = Conv2D(128, (1, 1), activation="relu", padding="same")(input)
br2 = Conv2D(128, (1, 7), activation="relu", padding="same")(br2)
br2 = Conv2D(128, (7, 1), activation="relu", padding="same")(br2)
merged = concatenate([br1, br2], axis=-1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
br = Conv2D(896, (1, 1), activation="linear", padding="same")(merged)
if scale_residual: br = Lambda(lambda b: b * 0.1)(br)
output = add([input, br])
output = BatchNormalization(axis=-1)(output)
output = Activation("relu")(output)
return output
def se_reduction_resnet_v2_B(input):
'''Architecture of a 17 * 17 to 8 * 8 Reduction_ResNet_B block.'''
rbr1 = MaxPooling2D((3,3), strides = (2,2), padding = "valid")(input)
rbr2 = Conv2D(256, (1, 1), activation = "relu", padding = "same")(input)
rbr2 = Conv2D(384, (3, 3), activation = "relu", strides = (2,2))(rbr2)
rbr3 = Conv2D(256, (1, 1), activation = "relu", padding = "same")(input)
rbr3 = Conv2D(288, (3, 3), activation = "relu", strides = (2,2))(rbr3)
rbr4 = Conv2D(256, (1, 1), activation = "relu", padding = "same")(input)
rbr4 = Conv2D(288, (3, 3), activation = "relu", padding = "same")(rbr4)
rbr4 = Conv2D(320, (3, 3), activation = "relu", strides = (2,2))(rbr4)
merged = concatenate([rbr1, rbr2, rbr3, rbr4], axis = -1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
rbr = BatchNormalization(axis = -1)(merged)
rbr = Activation("relu")(rbr)
return rbr
def inception_B(input):
'''Architecture of Inception_B block which is a 17 * 17 grid module.'''
b1 = AveragePooling2D((3, 3), strides = (1, 1), padding = "same")(input)
b1 = conv_block(b1, 128, 1, 1)
b2 = conv_block(input, 384, 1, 1)
b3 = conv_block(input, 192, 1, 1)
b3 = conv_block(b3, 224, 1, 7)
b3 = conv_block(b3, 256, 7, 1)
b4 = conv_block(input, 192, 1, 1)
b4 = conv_block(b4, 192, 7, 1)
b4 = conv_block(b4, 224, 1, 7)
b4 = conv_block(b4, 224, 7, 1)
b4 = conv_block(b4, 256, 1, 7)
merged = concatenate([b1, b2, b3, b4], axis = -1)
# squeeze and excite block
merged = squeeze_excite_block(merged)
return merged
def se_inception_v3(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""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')
# squeeze and excite block
x = squeeze_excite_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')
# squeeze and excite block
x = squeeze_excite_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')
# squeeze and excite block
x = squeeze_excite_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')
# squeeze and excite block
x = squeeze_excite_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')
# squeeze and excite block
x = squeeze_excite_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))
# squeeze and excite block
x = squeeze_excite_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')
# squeeze and excite block
x = squeeze_excite_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')
# squeeze and excite block
x = squeeze_excite_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))
# squeeze and excite block
x = squeeze_excite_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='SE_Inception_V3')
return model