def model(self):
shape = (1, 4, 4)
input = Input(shape=shape)
x = AveragePooling2D(data_format='channels_first')(input)
model = Model(inputs=input, outputs=x)
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 when using TensorFlow,
for best performance you should set
`image_data_format="channels_last"` in your Keras config
at ~/.keras/keras.json.
The model and the weights are compatible with both
TensorFlow and Theano. The data format
convention used by the model is the one
specified in your Keras config file.
# 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 `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 244)` (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 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=224,
min_size=197,
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_last':
bn_axis = 3
else:
bn_axis = 1
x = ZeroPadding2D((3, 3))(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x)
x = BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = Activation('relu')(x)
x = 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')
x = AveragePooling2D((7, 7), name='avg_pool')(x)
if include_top:
x = Flatten()(x)
x = Dense(classes, activation='softmax', name='fc1000')(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='resnet50')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH,
cache_subdir='models',
md5_hash='a7b3fe01876f51b976af0dea6bc144eb')
else:
weights_path = get_file(
'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
model.load_weights(weights_path)
if K.backend() == 'theano':
layer_utils.convert_all_kernels_in_model(model)
if K.image_data_format() == 'channels_first':
if include_top:
maxpool = model.get_layer(name='avg_pool')
shape = maxpool.output_shape[1:]
dense = model.get_layer(name='fc1000')
layer_utils.convert_dense_weights_data_format(
dense, shape, 'channels_first')
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
return model
def build(
cls,
img_size,
n_classes,
alpha=1.0,
weights_path=None,
train=False,
input_tensor=None):
"""Build an ICNet Model.
Args:
image_size (int): the size of each image. only square images are
supported.
n_classes (int): the number of output labels to predict.
weights_path (str): (optional) a path to a Keras model file to
load after the network is constructed. Useful for re-training.
train (bool): (optional) if true, add additional output nodes to
the network for training.
Returns:
model (keras.models.Model): A Keras model
"""
if img_size % 384 != 0:
raise Exception('`img_size` must be a multiple of 384.')
logger.info('Building ICNet model.')
inpt = Input(shape=(img_size, img_size, 3), tensor=input_tensor)
# The full scale branch
out_1 = cls._light_cnn_block(
inpt,
filter_scale=int(alpha * 32),
strides=[2, 2, 2],
include_projection=True,
block_name='sub1_conv'
)
# The 1/2 scale branch
out_2 = AveragePooling2D(pool_size=(2, 2), name='sub2_data')(inpt)
out_2 = cls._light_cnn_block(
out_2,
filter_scale=int(alpha * 32),
strides=[2, 1, 1],
block_name='sub2_conv'
)
out_2 = MaxPooling2D(
pool_size=3, strides=2, name='sub2_pool1_3x3'
)(out_2)
for layer_index in range(1, 4):
out_2 = cls._conv_block(
out_2,
filter_scale=int(alpha * 32),
include_projection=(layer_index == 1),
block_name='sub2_conv%d_%d' % (2, layer_index)
)
# The third large conv block gets split off into another branch.
out_2 = cls._conv_block(
out_2,
filter_scale=int(alpha * 64),
include_projection=True,
strides=[2, 1, 1],
block_name='sub2_conv%d_%d' % (3, 1)
)
# The 1/4 scale branch
out_4 = AveragePooling2D(pool_size=(2, 2), name='sub4_conv3_1')(out_2)
for layer_index in range(2, 5):
out_4 = cls._conv_block(
out_4,
filter_scale=int(alpha * 64),
block_name='sub4_conv%d_%d' % (3, layer_index)
)
for layer_index in range(1, 7):
out_4 = cls._conv_block(
out_4,
filter_scale=int(alpha * 128),
dilation_rate=2,
include_projection=(layer_index == 1),
block_name='sub4_conv%d_%d' % (4, layer_index)
)
for sub_index in range(1, 4):
out_4 = cls._conv_block(
out_4,
filter_scale=int(alpha * 256),
dilation_rate=4,
include_projection=(sub_index == 1),
block_name='sub4_conv%d_%d' % (5, sub_index)
)
# In this version we've fixed the input dimensions to be square
# We also are restricting dimsensions to be multiples of 384 which
# will allow us to use standard upsampling layers for resizing.
pool_height, _ = out_4.shape[1:3].as_list()
pool_scale = int(img_size / 384)
pool1 = AveragePooling2D(pool_size=pool_height,
strides=pool_height,
name='sub4_conv5_3_pool1')(out_4)
pool1 = UpSampling2D(size=12 * pool_scale,
name='sub4_conv5_3_pool1_interp',
interpolation='bilinear')(pool1)
pool2 = AveragePooling2D(pool_size=pool_height // 2,
strides=pool_height // 2,
name='sub4_conv5_3_pool2')(out_4)
pool2 = UpSampling2D(size=6 * pool_scale,
name='sub4_conv5_3_pool2_interp',
interpolation='bilinear')(pool2)
pool3 = AveragePooling2D(pool_size=pool_height // 3,
strides=pool_height // 3,
name='sub4_conv5_3_pool3')(out_4)
pool3 = UpSampling2D(size=4 * pool_scale,
name='sub4_conv5_3_pool3_interp',
interpolation='bilinear')(pool3)
pool4 = AveragePooling2D(pool_size=pool_height // 4,
strides=pool_height // 4,
name='sub4_conv5_3_pool4')(out_4)
pool4 = UpSampling2D(size=3 * pool_scale,
name='sub4_conv5_3_pool6_interp',
interpolation='bilinear')(pool4)
out_4 = Add(
name='sub4_conv5_3_sum'
)([out_4, pool1, pool2, pool3, pool4])
out_4 = Conv2D(
filters=int(alpha * 256),
kernel_size=1,
activation='relu',
use_bias=False,
name='sub4_conv5_4_k1')(out_4)
out_4 = BatchNormalization(name='sub4_conv5_4_k1_bn')(out_4)
out_2, aux_1 = cls._cff_block(
out_4,
out_2,
int(alpha * 128),
block_name='sub24_cff',
include_projection=True
)
out_1, aux_2 = cls._cff_block(
out_2,
out_1,
int(alpha * 128),
block_name='sub12_cff'
)
out_1 = UpSampling2D(size=(2, 2), name='sub12_sum_interp',
interpolation='bilinear')(out_1)
out_1 = Conv2D(n_classes, 1, activation='softmax',
name='conv6_cls')(out_1)
out = UpSampling2D(size=(4, 4), name='conv6_interp',
interpolation='bilinear')(out_1)
if train:
aux_1 = Conv2D(n_classes, 1, activation='softmax',
name='sub4_out')(aux_1)
aux_2 = Conv2D(n_classes, 1, activation='softmax',
name='sub24_out')(aux_2)
# The loss during training is generated from these three outputs.
# The final output layer is not needed.
model = Model(inputs=inpt, outputs=[out_1, aux_2, aux_1])
else:
model = Model(inputs=inpt, outputs=out)
if weights_path is not None:
if weights_path.startswith('gs://'):
weights_path = _copy_file_from_gcs(weights_path)
logger.info('Loading weights from %s.' % weights_path)
model.load_weights(weights_path, by_name=True)
logger.info('Done building model.')
return model
def resnet_v1(self, input_shape, depth, num_classes=10):
"""ResNet Version 1 Model resnet_layer [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 = self.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 = self.resnet_layer(inputs=x,
num_filters=num_filters,
strides=strides)
y = self.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 = self.resnet_layer(inputs=x,
num_filters=num_filters,
kernel_size=1,
strides=strides,
activation=None,
batch_normalization=False)
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
def get_inception_v3_unet(input_shape, weights='imagenet'):
inp = Input(input_shape + (9,))
x = inc_conv2d_bn(inp, 32, 3, 3, strides=(2, 2), padding='same')
x = inc_conv2d_bn(x, 32, 3, 3, padding='same')
x = inc_conv2d_bn(x, 64, 3, 3)
conv1 = x
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = inc_conv2d_bn(x, 80, 1, 1, padding='same')
x = inc_conv2d_bn(x, 192, 3, 3, padding='same')
conv2 = x
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
# mixed 0, 1, 2: 35 x 35 x 256
branch1x1 = inc_conv2d_bn(x, 64, 1, 1)
branch5x5 = inc_conv2d_bn(x, 48, 1, 1)
branch5x5 = inc_conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = inc_conv2d_bn(x, 64, 1, 1)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 32, 1, 1)
x = concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed0')
# mixed 1: 35 x 35 x 256
branch1x1 = inc_conv2d_bn(x, 64, 1, 1)
branch5x5 = inc_conv2d_bn(x, 48, 1, 1)
branch5x5 = inc_conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = inc_conv2d_bn(x, 64, 1, 1)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 64, 1, 1)
x = concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed1')
# mixed 2: 35 x 35 x 256
branch1x1 = inc_conv2d_bn(x, 64, 1, 1)
branch5x5 = inc_conv2d_bn(x, 48, 1, 1)
branch5x5 = inc_conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = inc_conv2d_bn(x, 64, 1, 1)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 64, 1, 1)
x = concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed2')
conv3 = x
# mixed 3: 17 x 17 x 768
branch3x3 = inc_conv2d_bn(x, 384, 3, 3, strides=(2, 2), padding='same')
branch3x3dbl = inc_conv2d_bn(x, 64, 1, 1)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = inc_conv2d_bn(
branch3x3dbl, 96, 3, 3, strides=(2, 2), padding='same')
branch_pool = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = concatenate(
[branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed3')
# mixed 4: 17 x 17 x 768
branch1x1 = inc_conv2d_bn(x, 192, 1, 1)
branch7x7 = inc_conv2d_bn(x, 128, 1, 1)
branch7x7 = inc_conv2d_bn(branch7x7, 128, 1, 7)
branch7x7 = inc_conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = inc_conv2d_bn(x, 128, 1, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 128, 1, 7)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 192, 1, 1)
x = 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 = inc_conv2d_bn(x, 192, 1, 1)
branch7x7 = inc_conv2d_bn(x, 160, 1, 1)
branch7x7 = inc_conv2d_bn(branch7x7, 160, 1, 7)
branch7x7 = inc_conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = inc_conv2d_bn(x, 160, 1, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 160, 1, 7)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 192, 1, 1)
x = concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(5 + i))
# mixed 7: 17 x 17 x 768
branch1x1 = inc_conv2d_bn(x, 192, 1, 1)
branch7x7 = inc_conv2d_bn(x, 192, 1, 1)
branch7x7 = inc_conv2d_bn(branch7x7, 192, 1, 7)
branch7x7 = inc_conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = inc_conv2d_bn(x, 192, 1, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 192, 1, 7)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = inc_conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 192, 1, 1)
x = concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed7')
conv4 = x
# mixed 8: 8 x 8 x 1280
branch3x3 = inc_conv2d_bn(x, 192, 1, 1)
branch3x3 = inc_conv2d_bn(branch3x3, 320, 3, 3,
strides=(2, 2), padding='same')
branch7x7x3 = inc_conv2d_bn(x, 192, 1, 1)
branch7x7x3 = inc_conv2d_bn(branch7x7x3, 192, 1, 7)
branch7x7x3 = inc_conv2d_bn(branch7x7x3, 192, 7, 1)
branch7x7x3 = inc_conv2d_bn(
branch7x7x3, 192, 3, 3, strides=(2, 2), padding='same')
branch_pool = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
x = concatenate(
[branch3x3, branch7x7x3, branch_pool], axis=channel_axis, name='mixed8')
# mixed 9: 8 x 8 x 2048
for i in range(2):
branch1x1 = inc_conv2d_bn(x, 320, 1, 1)
branch3x3 = inc_conv2d_bn(x, 384, 1, 1)
branch3x3_1 = inc_conv2d_bn(branch3x3, 384, 1, 3)
branch3x3_2 = inc_conv2d_bn(branch3x3, 384, 3, 1)
branch3x3 = concatenate(
[branch3x3_1, branch3x3_2], axis=channel_axis, name='mixed9_' + str(i))
branch3x3dbl = inc_conv2d_bn(x, 448, 1, 1)
branch3x3dbl = inc_conv2d_bn(branch3x3dbl, 384, 3, 3)
branch3x3dbl_1 = inc_conv2d_bn(branch3x3dbl, 384, 1, 3)
branch3x3dbl_2 = inc_conv2d_bn(branch3x3dbl, 384, 3, 1)
branch3x3dbl = concatenate(
[branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis)
branch_pool = AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = inc_conv2d_bn(branch_pool, 192, 1, 1)
x = concatenate(
[branch1x1, branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(9 + i))
conv5 = x
up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1)
conv6 = conv_block(up6, 160)
conv6 = conv_block(conv6, 160)
up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1)
conv7 = conv_block(up7, 128)
conv7 = conv_block(conv7, 128)
up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1)
conv8 = conv_block(up8, 96)
conv8 = conv_block(conv8, 96)
up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1)
conv9 = conv_block(up9, 64)
conv9 = conv_block(conv9, 64)
up10 = concatenate([UpSampling2D()(conv9), inp], axis=-1)
conv10 = conv_block(up10, 48)
conv10 = conv_block(conv10, 48)
res = Conv2D(1, (1, 1), activation='sigmoid')(conv10)
model = Model(inp, res)
if weights == 'imagenet':
inception_v3 = InceptionV3(weights=weights, include_top=False, input_shape=input_shape + (3,))
for i in range(2, len(inception_v3.layers)):
model.layers[i].set_weights(inception_v3.layers[i].get_weights())
model.layers[i].trainable = False
return model
def create_inception_v4(nb_classes=1001, load_weights=True):
'''
Creates a inception v4 network
:param nb_classes: number of classes.txt
:return: Keras Model with 1 input and 1 output
'''
if K.image_data_format() == 'th':
init = Input((3, 299, 299))
else:
init = Input((299, 299, 3))
# Input Shape is 299 x 299 x 3 (tf) or 3 x 299 x 299 (th)
x = inception_stem(init)
# 4 x Inception A
for i in range(4):
x = inception_A(x)
# Reduction A
x = reduction_A(x)
# 7 x Inception B
for i in range(7):
x = inception_B(x)
# Reduction B
x = reduction_B(x)
# 3 x Inception C
for i in range(3):
x = inception_C(x)
# Average Pooling
x = AveragePooling2D((8, 8))(x)
# Dropout
x = Dropout(0.8)(x)
x = Flatten()(x)
# Output
out = Dense(output_dim=nb_classes, activation='softmax')(x)
model = Model(init, out, name='Inception-v4')
if load_weights:
if K.backend() == "theano":
if K.image_data_format() == "th":
weights = get_file(
'inception_v4_weights_th_dim_ordering_th_kernels.h5',
TH_BACKEND_TH_DIM_ORDERING,
cache_subdir='models')
else:
weights = get_file(
'inception_v4_weights_tf_dim_ordering_th_kernels.h5',
TH_BACKEND_TF_DIM_ORDERING,
cache_subdir='models')
else:
if K.image_data_format() == "th":
weights = get_file(
'inception_v4_weights_th_dim_ordering_tf_kernels.h5',
TF_BACKEND_TH_DIM_ORDERING,
cache_subdir='models')
else:
weights = get_file(
'inception_v4_weights_tf_dim_ordering_tf_kernels.h5',
TH_BACKEND_TF_DIM_ORDERING,
cache_subdir='models')
model.load_weights(weights)
print("Model weights loaded.")
return model
def ResNet50(input_shape=(64, 64, 3), classes=6):
"""
实现ResNet50
CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
-> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
参数：
input_shape - 图像数据集的维度
classes - 整数，分类数
返回：
model - Keras框架的模型
"""
# 定义tensor类型的输入数据
X_input = Input(input_shape)
# 0填充
X = ZeroPadding2D((3, 3))(X_input)
# stage1
X = Conv2D(filters=64, kernel_size=(7, 7), strides=(2, 2), name="conv1",
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name="bn_conv1")(X)
X = Activation("relu")(X)
X = MaxPooling2D(pool_size=(3, 3), strides=(2, 2))(X)
# stage2
X = convolutional_block(X, f=3, filters=[64, 64, 256], stage=2, block="a", s=1)
X = identity_block(X, f=3, filters=[64, 64, 256], stage=2, block="b")
X = identity_block(X, f=3, filters=[64, 64, 256], stage=2, block="c")
# stage3
X = convolutional_block(X, f=3, filters=[128, 128, 512], stage=3, block="a", s=2)
X = identity_block(X, f=3, filters=[128, 128, 512], stage=3, block="b")
X = identity_block(X, f=3, filters=[128, 128, 512], stage=3, block="c")
X = identity_block(X, f=3, filters=[128, 128, 512], stage=3, block="d")
# stage4
X = convolutional_block(X, f=3, filters=[256, 256, 1024], stage=4, block="a", s=2)
X = identity_block(X, f=3, filters=[256, 256, 1024], stage=4, block="b")
X = identity_block(X, f=3, filters=[256, 256, 1024], stage=4, block="c")
X = identity_block(X, f=3, filters=[256, 256, 1024], stage=4, block="d")
X = identity_block(X, f=3, filters=[256, 256, 1024], stage=4, block="e")
X = identity_block(X, f=3, filters=[256, 256, 1024], stage=4, block="f")
# stage5
X = convolutional_block(X, f=3, filters=[512, 512, 2048], stage=5, block="a", s=2)
X = identity_block(X, f=3, filters=[512, 512, 2048], stage=5, block="b")
X = identity_block(X, f=3, filters=[512, 512, 2048], stage=5, block="c")
# 均值池化层
X = AveragePooling2D(pool_size=(2, 2), padding="same")(X)
# 输出层
X = Flatten()(X)
X = Dense(classes, activation="softmax", name="fc" + str(classes),
kernel_initializer=glorot_uniform(seed=0))(X)
# 创建模型
model = Model(inputs=X_input, outputs=X, name="ResNet50")
return model
def ResNet50(input_shape, classes):
# Define the input as a tensor with shape input_shape
X_input = Input(input_shape)
# Zero-Padding
X = ZeroPadding2D((3, 3))(X_input)
# Stage 1
X = Conv2D(64, (7, 7),
strides=(2, 2),
name='conv1',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# Stage 2
X = convolutional_block(X,
f=3,
filters=[64, 64, 256],
stage=2,
block='a',
s=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')
# Stage 3
X = convolutional_block(X,
f=3,
filters=[128, 128, 512],
stage=3,
block='a',
s=2)
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')
# Stage 4
X = convolutional_block(X,
f=3,
filters=[256, 256, 1024],
stage=4,
block='a',
s=2)
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')
# Stage 5
X = convolutional_block(X,
f=3,
filters=[512, 512, 2048],
stage=5,
block='a',
s=2)
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='b')
X = identity_block(X, 3, [512, 512, 2048], stage=5, block='c')
# AVGPOOL
X = AveragePooling2D(pool_size=(2, 2),
padding='same',
data_format='channels_last')(X)
# output layer
X = Flatten()(X)
X = Dense(classes,
activation='softmax',
name='fc' + str(classes),
kernel_initializer=glorot_uniform(seed=0))(X)
# Create model
model = Model(inputs=X_input, outputs=X, name='ResNet50')
return model
Conv2D(128,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
activation='relu'))
model.add(
Conv2D(128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu'))
model.add(
AveragePooling2D(pool_size=(7, 7),
strides=(1, 1),
padding='same',
data_format=None)) # (None, 7, 7, 128)
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4, activation='softmax'))
sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
adam = Adam(lr=0.0001,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
def InceptionResNetV2(include_top=True,
weights='imagenet',
weights_path=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
'''Instantiates the Inception-ResNet v2 architecture.
Optionally loads weights pre-trained on ImageNet.
Note that when using TensorFlow, for best performance you should
set `"image_data_format": "channels_last"` in your Keras config
at `~/.keras/keras.json`.
Note that the default input image size for this model is 299x299, instead
of 224x224 as in the VGG16 and ResNet models. Also, the input preprocessing
function is different (i.e., do not use `imagenet_utils.preprocess_input()`
with this model. Use `preprocess_input()` defined in this module instead).
# 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.
RuntimeError: If attempting to run this model with an unsupported backend.
'''
if K.backend() in {'cntk'}:
raise RuntimeError(K.backend() +
' backend is currently unsupported for this model.')
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
# 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=False,
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
# 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 = MaxPooling2D(3, strides=2)(x)
x = conv2d_bn(x, 80, 1, padding='valid')
x = conv2d_bn(x, 192, 3, padding='valid')
x = 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 = 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 K.image_data_format() == 'channels_first' else 3
x = 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 = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
x = 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 = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = 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 = 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_resnet_v2')
print("Loading Weights")
# Load weights
if weights == 'imagenet':
if K.image_data_format() == 'channels_first':
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
model.load_weights(weights_path)
print("Weights loaded successfully")
model.layers.pop()
print("Number of layers: ", len(model.layers))
for layer in model.layers:
layer.trainable = True
x = Dense(N_CLASSES, activation='softmax',
name='predictions')(model.layers[-1].output)
x.trainable = True
model = Model(inputs, x)
print("Saving Weights: ")
model.save_weights('saved_weights.h5')
return model
def define_model(weight_path=None):
input = Input(shape=(224, 224, 3))
conv1_7x7_s2 = Conv2D(filters=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='same',
activation='relu',
kernel_regularizer=l2(0.01))(input)
maxpool1_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(conv1_7x7_s2)
conv2_3x3_reduce = Conv2D(filters=64,
kernel_size=(1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(0.01))(maxpool1_3x3_s2)
conv2_3x3 = Conv2D(filters=192,
kernel_size=(3, 3),
padding='same',
activation='relu',
kernel_regularizer=l2(0.01))(conv2_3x3_reduce)
maxpool2_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(conv2_3x3)
inception_3a = inception_model(input=maxpool2_3x3_s2,
filters_1x1=64,
filters_3x3_reduce=96,
filters_3x3=128,
filters_5x5_reduce=16,
filters_5x5=32,
filters_pool_proj=32)
inception_3b = inception_model(input=inception_3a,
filters_1x1=128,
filters_3x3_reduce=128,
filters_3x3=192,
filters_5x5_reduce=32,
filters_5x5=96,
filters_pool_proj=64)
maxpool3_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(inception_3b)
inception_4a = inception_model(input=maxpool3_3x3_s2,
filters_1x1=192,
filters_3x3_reduce=96,
filters_3x3=208,
filters_5x5_reduce=16,
filters_5x5=48,
filters_pool_proj=64)
inception_4b = inception_model(input=inception_4a,
filters_1x1=160,
filters_3x3_reduce=112,
filters_3x3=224,
filters_5x5_reduce=24,
filters_5x5=64,
filters_pool_proj=64)
inception_4c = inception_model(input=inception_4b,
filters_1x1=128,
filters_3x3_reduce=128,
filters_3x3=256,
filters_5x5_reduce=24,
filters_5x5=64,
filters_pool_proj=64)
inception_4d = inception_model(input=inception_4c,
filters_1x1=112,
filters_3x3_reduce=144,
filters_3x3=288,
filters_5x5_reduce=32,
filters_5x5=64,
filters_pool_proj=64)
inception_4e = inception_model(input=inception_4d,
filters_1x1=256,
filters_3x3_reduce=160,
filters_3x3=320,
filters_5x5_reduce=32,
filters_5x5=128,
filters_pool_proj=128)
maxpool4_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(inception_4e)
inception_5a = inception_model(input=maxpool4_3x3_s2,
filters_1x1=256,
filters_3x3_reduce=160,
filters_3x3=320,
filters_5x5_reduce=32,
filters_5x5=128,
filters_pool_proj=128)
inception_5b = inception_model(input=inception_5a,
filters_1x1=384,
filters_3x3_reduce=192,
filters_3x3=384,
filters_5x5_reduce=48,
filters_5x5=128,
filters_pool_proj=128)
averagepool1_7x7_s1 = AveragePooling2D(pool_size=(7, 7),
strides=(7, 7),
padding='same')(inception_5b)
drop1 = Dropout(rate=0.4)(averagepool1_7x7_s1)
linear = Dense(units=1000,
activation='softmax',
kernel_regularizer=l2(0.01))(
keras.layers.core.Flatten(drop1))
last = linear
model = Model(inputs=input, outputs=last)
model.summary()
def ResNet152(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
large_input=False,
pooling=None,
classes=1000):
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')
eps = 1.1e-5
if large_input:
img_size = 448
else:
img_size = 224
# Determine proper input shape
input_shape = (224, 224, 3)
print(input_shape)
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
# handle dimension ordering for different backends
if Kb.image_dim_ordering() == 'tf':
bn_axis = 3
else:
bn_axis = 1
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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 large_input:
x = AveragePooling2D((14, 14), name='avg_pool')(x)
else:
x = AveragePooling2D((7, 7), name='avg_pool')(x)
# include classification layer by default, not included for feature extraction
if include_top:
x = Flatten()(x)
x = Dense(classes, activation='softmax', name='fc1000')(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='resnet152')
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'resnet152_weights_tf.h5',
WEIGHTS_PATH,
cache_subdir='models',
md5_hash='cdb18a2158b88e392c0905d47dcef965')
else:
weights_path = get_file(
'resnet152_weights_tf_notop.h5',
WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='4a90dcdafacbd17d772af1fb44fc2660')
model.load_weights(weights_path, by_name=True)
return model
## build model
input = Input(shape=(img_height, img_width, channels))
out = Conv2D(filters=64, strides=2, kernel_size=7, padding="same")(input)
out = MaxPooling2D((2, 2))(out)
for _ in range(3):
out = block_2(out, kernel_size=3, strides=1, filters=64)
out = block_1(out, kernel_size=3, strides=2, filters=128)
for _ in range(3):
out = block_2(out, kernel_size=3, strides=1, filters=128)
out = block_1(out, kernel_size=3, strides=2, filters=256)
for _ in range(5):
out = block_2(out, kernel_size=3, strides=1, filters=256)
out = block_1(out, kernel_size=3, strides=2, filters=512)
for _ in range(2):
out = block_2(out, kernel_size=3, strides=1, filters=512)
out = AveragePooling2D(pool_size=(7, 7))(out)
out = Flatten()(out)
output = Dense(1000)(out)
model = Model(input=input, output=output)
model.summary()
if epoch < 5:
return 0.001
elif epoch < 10:
return .0002
elif epoch < 15:
return 0.00002
else:
return .0000005
shape = (224, 224, 3)
X_train, X_test = setup_generator('food-101/train', 'food-101/test', 32, shape[:2])
base_model = InceptionV3(weights='imagenet', include_top=False, input_tensor=Input(shape=(224, 224, 3)))
x = base_model.output
x = AveragePooling2D()(x)
x = Dropout(.5)(x)
x = Flatten()(x)
predictions = Dense(X_train.num_classes, init='glorot_uniform', W_regularizer=l2(.0005), activation='softmax')(x)
model = Model(input=base_model.input, output=predictions)
opt = SGD(lr=.1, momentum=.9)
model.compile(optimizer=opt, loss='categorical_crossentropy', metrics=['accuracy'])
checkpointer = ModelCheckpoint(filepath='model.{epoch:02d}-{val_loss:.2f}.hdf5', verbose=1, save_best_only=True)
csv_logger = CSVLogger('model.log')
lr_scheduler = LearningRateScheduler(schedule)
def InceptionResNetV2(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the Inception-ResNet v2 architecture.
Optionally loads weights pre-trained on ImageNet.
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 and the weights are compatible with TensorFlow, Theano and
CNTK backends. The data format convention used by the model is
the one specified in your Keras config file.
Note that the default input image size for this model is 299x299, instead
of 224x224 as in the VGG16 and ResNet models. Also, the input preprocessing
function is different (i.e., do not use `imagenet_utils.preprocess_input()`
with this model. Use `preprocess_input()` defined in this module instead).
# 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 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 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=139,
data_format=K.image_data_format(),
require_flatten=False,
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
# 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 = MaxPooling2D(3, strides=2)(x)
x = conv2d_bn(x, 80, 1, padding='valid')
x = conv2d_bn(x, 192, 3, padding='valid')
x = 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 = 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 K.image_data_format() == 'channels_first' else 3
x = 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 = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
x = 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 = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = 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 = 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_resnet_v2')
# Load weights
if weights == 'imagenet':
if K.image_data_format() == 'channels_first':
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
if include_top:
weights_filename = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5'
weights_path = get_file(weights_filename,
BASE_WEIGHT_URL + weights_filename,
cache_subdir='models',
file_hash='e693bd0210a403b3192acc6073ad2e96')
else:
weights_path = pre_trained_model_dir
# weights_filename = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5'
# weights_path = get_file(weights_filename,
# BASE_WEIGHT_URL + weights_filename,
# cache_subdir='models',
# file_hash='d19885ff4a710c122648d3b5c3b684e4')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
def DeepModel(size_set=800):
img_input = Input(shape=(size_set, size_set, 3))
scale_img_2 = AveragePooling2D(pool_size=(2, 2))(img_input)
scale_img_3 = AveragePooling2D(pool_size=(2, 2))(scale_img_2)
scale_img_4 = AveragePooling2D(pool_size=(2, 2))(scale_img_3)
conv1 = Conv2D(32, (3, 3),
padding='same',
activation='relu',
name='block1_conv1')(img_input)
conv1 = Conv2D(32, (3, 3),
padding='same',
activation='relu',
name='block1_conv2')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
input2 = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block2_input1')(scale_img_2)
input2 = concatenate([input2, pool1], axis=3)
conv2 = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block2_conv1')(input2)
conv2 = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block2_conv2')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
input3 = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block3_input1')(scale_img_3)
input3 = concatenate([input3, pool2], axis=3)
conv3 = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block3_conv1')(input3)
conv3 = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block3_conv2')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
input4 = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block4_input1')(scale_img_4)
input4 = concatenate([input4, pool3], axis=3)
conv4 = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block4_conv1')(input4)
conv4 = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block4_conv2')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Conv2D(512, (3, 3),
padding='same',
activation='relu',
name='block5_conv1')(pool4)
conv5 = Conv2D(512, (3, 3),
padding='same',
activation='relu',
name='block5_conv2')(conv5)
up6 = concatenate([
Conv2DTranspose(
256, (2, 2), strides=(2, 2), padding='same',
name='block6_dconv')(conv5), conv4
],
axis=3)
conv6 = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block6_conv1')(up6)
conv6 = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block6_conv2')(conv6)
up7 = concatenate([
Conv2DTranspose(
128, (2, 2), strides=(2, 2), padding='same',
name='block7_dconv')(conv6), conv3
],
axis=3)
conv7 = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block7_conv1')(up7)
conv7 = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block7_conv2')(conv7)
up8 = concatenate([
Conv2DTranspose(
64, (2, 2), strides=(2, 2), padding='same',
name='block8_dconv')(conv7), conv2
],
axis=3)
conv8 = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block8_conv1')(up8)
conv8 = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block8_conv2')(conv8)
up9 = concatenate([
Conv2DTranspose(
32, (2, 2), strides=(2, 2), padding='same',
name='block9_dconv')(conv8), conv1
],
axis=3)
conv9 = Conv2D(32, (3, 3),
padding='same',
activation='relu',
name='block9_conv1')(up9)
conv9 = Conv2D(32, (3, 3),
padding='same',
activation='relu',
name='block9_conv2')(conv9)
side6 = UpSampling2D(size=(8, 8))(conv6)
side7 = UpSampling2D(size=(4, 4))(conv7)
side8 = UpSampling2D(size=(2, 2))(conv8)
out6 = Conv2D(2, (1, 1), activation='sigmoid', name='side_63')(side6)
out7 = Conv2D(2, (1, 1), activation='sigmoid', name='side_73')(side7)
out8 = Conv2D(2, (1, 1), activation='sigmoid', name='side_83')(side8)
out9 = Conv2D(2, (1, 1), activation='sigmoid', name='side_93')(conv9)
out10 = average([out6, out7, out8, out9])
model = Model(inputs=[img_input], outputs=[out6, out7, out8, out9, out10])
return model
def ResNet50(input_shape=(64, 64, 3), classes=6):
"""
Arguments:
input_shape -- shape of the images of the dataset
classes -- integer, number of classes
Returns:
model -- a Model() instance in Keras
"""
# Define the input as a tensor with shape input_shape
X_input = Input(input_shape)
print(X_input.shape)
# Zero-Padding
X = ZeroPadding2D((3, 3))(X_input)
# Stage 1
X = Conv2D(64, (7, 7),
strides=(2, 2),
name='conv1',
kernel_initializer=glorot_uniform(seed=0))(X)
X = BatchNormalization(axis=3, name='bn_conv1')(X)
X = Activation('relu')(X)
print(X.shape)
X = ZeroPadding2D((1, 1))(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# Stage 2
X = convolutional_block(X,
f=3,
filters=[64, 64, 256],
stage=2,
block=1,
s=1)
X = multiple_identity_block(X,
3, [64, 64, 256],
stage=2,
block=1,
iterator=2)
print(X.shape)
### START CODE HERE ###
# Stage 3 (≈4 lines)
X = convolutional_block(X,
f=3,
filters=[128, 128, 512],
stage=3,
block=1,
s=2)
X = X = multiple_identity_block(X,
3, [128, 128, 512],
stage=3,
block=1,
iterator=3)
print(X.shape)
# Stage 4 (≈6 lines)
X = convolutional_block(X,
f=3,
filters=[256, 256, 1024],
stage=4,
block=1,
s=2)
X = multiple_identity_block(X,
3, [256, 256, 1024],
stage=4,
block=1,
iterator=5)
print(X.shape)
# Stage 5 (≈3 lines)
X = convolutional_block(X,
f=3,
filters=[512, 512, 2048],
stage=5,
block=1,
s=2)
X = multiple_identity_block(X,
3, [512, 512, 2048],
stage=5,
block=1,
iterator=2)
print(X.shape)
# AVGPOOL (≈1 line). Use "X = AveragePooling2D(...)(X)"
X = AveragePooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None)(X)
### END CODE HERE ###
# output layer
X = Flatten()(X)
X = Dense(classes,
activation='softmax',
name='fc' + str(classes),
kernel_initializer=glorot_uniform(seed=0))(X)
print(X.shape)
# Create model
model = Model(inputs=X_input, outputs=X, name="Resnet50")
return model
def resnet152_model(img_rows, img_cols, color_type=1, num_classes=None):
"""
Resnet 152 Model for Keras
Model Schema and layer naming follow that of the original Caffe implementation
https://github.com/KaimingHe/deep-residual-networks
ImageNet Pretrained Weights
Theano: https://drive.google.com/file/d/0Byy2AcGyEVxfZHhUT3lWVWxRN28/view?usp=sharing
TensorFlow: https://drive.google.com/file/d/0Byy2AcGyEVxfeXExMzNNOHpEODg/view?usp=sharing
Parameters:
img_rows, img_cols - resolution of inputs
channel - 1 for grayscale, 3 for color
num_classes - number of class labels for our classification task
"""
eps = 1.1e-5
# Handle Dimension Ordering for different backends
global bn_axis
if K.image_dim_ordering() == 'tf':
bn_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
bn_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(64, 7, 7, subsample=(2, 2), name='conv1', bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=bn_axis, name='bn_conv1')(x)
x = Scale(axis=bn_axis, name='scale_conv1')(x)
x = Activation('relu', name='conv1_relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(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')
for i in range(1, 8):
x = identity_block(x, 3, [128, 128, 512], stage=3, block='b' + str(i))
x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a')
for i in range(1, 36):
x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b' + str(i))
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')
x_fc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_fc = Flatten()(x_fc)
x_fc = Dense(1000, activation='softmax', name='fc1000')(x_fc)
model = Model(img_input, x_fc)
weights_path = resnet152_weights
# if K.image_dim_ordering() == 'th':
# # Use pre-trained weights for Theano backend
# weights_path = 'imagenet_models/resnet152_weights_th.h5'
# else:
# # Use pre-trained weights for Tensorflow backend
# weights_path = 'imagenet_models/resnet152_weights_tf.h5'
model.load_weights(weights_path, by_name=True)
# Truncate and replace softmax layer for transfer learning
# Cannot use model.layers.pop() since model is not of Sequential() type
# The method below works since pre-trained weights are stored in layers but not in the model
x_newfc = AveragePooling2D((7, 7), name='avg_pool')(x)
x_newfc = Flatten()(x_newfc)
x_newfc = Dense(num_classes, activation='softmax', name='fc8')(x_newfc)
model = Model(img_input, x_newfc)
# Learning rate is changed to 0.001
# sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
# model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])
return model
X_train = X_train.reshape(X_train.shape[0], IMG_SIZE, IMG_SIZE, 1)
'''
Define model structure.
'''
#Initialize model.
model = Sequential()
#Convolutional layers with pooling.
model.add(
Conv2D(32, (5, 5), activation="relu", input_shape=(IMG_SIZE, IMG_SIZE, 1)))
model.add(MaxPooling2D(pool_size=(5, 5), strides=(2, 2)))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Conv2D(128, (3, 3), activation="relu"))
model.add(Conv2D(128, (3, 3), activation="relu"))
model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
#Fully connected layer followed by 0.5 dropout.
model.add(Flatten())
model.add(Dense(1024, activation="relu"))
model.add(Dropout(0.5))
#Output layer.
model.add(Dense(NUM_CLASSES, activation="softmax"))
#Compile model.
model.compile(loss="categorical_crossentropy",
model.add(
Convolution2D(32, 3, 3, border_mode='valid',
input_shape=X_train.shape[1:])) # C1 卷积层
model.add(Activation('relu')) # 激活函数：relu, tanh, sigmoid
model.add(Convolution2D(32, 3, 3)) # C2 卷积层
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2))) # S3 池化
model.add(Dropout(0.25)) #
model.add(Convolution2D(64, 3, 3, border_mode='valid')) # C4
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3)) # C5
model.add(Activation('relu'))
model.add(AveragePooling2D(pool_size=(2, 2))) # S6
model.add(Dropout(0.25))
model.add(Flatten()) # bottleneck 瓶颈
model.add(Dense(512)) # F7 全连接层, 512个神经元
model.add(Activation('relu')) #
model.add(Dropout(0.5))
model.add(Dense(nb_classes)) # label为0~9共10个类别
model.add(Activation('softmax')) # softmax 分类器
model.summary() # 模型小节
print("建模CNN完成 ...")
###################
# 2. 训练CNN模型
###################
def resnet_v2(input_shape, depth, num_classes=10, activation='relu'):
"""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 = activation
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)
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(activation)(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 createGoogLeNet():
# Our shape is 3 for the RGB, 224 for number of pixels in the width, 224 for the number of pixels in the height.
input = Input(shape=(3, 224, 224))
# First convolution layer of googLeNet has a patch size of 7x7 and a stride of 2 pixels.
# Has an output size of 64, a filter of height 7px, and a stride of 2pixels. These are specified in the first three parameters
# padding='same', I am going with same as im pretty sure its what the original GoogLeNet used.
# we are using the relu activation.
conv1 = Conv2D(64, 7, 2, padding='same', activation='relu')(input)
# Next we max pool. We pass conv1 as we want to hook up our layers.
pool1 = MaxPooling2D(3, 2, padding='same', data_format=None)(conv1)
# Next another 2D convolution
conv2 = Conv2D(192, 3, 1, padding='same', activation='relu')(pool1)
# Pooling layer
pool2 = MaxPooling2D(3, 2, padding='same', data_format=None)(conv2)
#Now we create the inception layers which are just 2D convolution layers
inception3A_1 = Conv2D(64, 1, 1, padding='same', activation='relu')(pool2)
inception3A_3_reduce = Conv2D(96, 1, 1, padding='same',
activation='relu')(pool2)
inception3A_3 = Conv2D(128, 3, 3, padding='same',
activation='relu')(inception3A_3_reduce)
inception3A_5_reduce = Conv2D(16, 1, 1, padding='same',
activation='relu')(pool2)
inception3A_5 = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception3A_5_reduce)
inception3APool = MaxPooling2D(3, 1, padding='same')(pool2)
inception3APoolProj = Conv2D(32, 1, 1, padding='same',
activation='relu')(inception3APool)
inception3AMerged = concatenate(
[inception3A_1, inception3A_3, inception3A_5, inception3APoolProj], 1)
#Inception 3b
inception3B_1 = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception3AMerged)
inception3B_3_reduce = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception3AMerged)
inception3B_3 = Conv2D(192, 3, 3, padding='same',
activation='relu')(inception3B_3_reduce)
inception3B_5_reduce = Conv2D(32, 1, 1, padding='same',
activation='relu')(inception3AMerged)
inception3B_5 = Conv2D(96, 1, 1, padding='same',
activation='relu')(inception3B_5_reduce)
inception3BPool = MaxPooling2D(3, 1, padding='same')(inception3AMerged)
inception3BPoolProj = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception3BPool)
inception3BMerged = concatenate(
[inception3B_1, inception3B_3, inception3B_5, inception3BPoolProj], 1)
#Max pool
pool3 = MaxPooling2D(3, 2, padding='same',
data_format=None)(inception3inception3BMerged)
#Inception 4A
inception4A_1 = Conv2D(192, 1, 1, padding='same', activation='relu')(pool3)
inception4A_3_reduce = Conv2D(96, 1, 1, padding='same',
activation='relu')(pool3)
inception4A_3 = Conv2D(208, 3, 3, padding='same',
activation='relu')(inception4A_3_reduce)
inception4A_5_reduce = Conv2D(16, 1, 1, padding='same',
activation='relu')(pool3)
inception4A_5 = Conv2D(48, 1, 1, padding='same',
activation='relu')(inception4A_5_reduce)
inception4APool = MaxPooling2D(3, 1, padding='same')(pool3)
inception4APoolProj = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4APool)
inception4AMerged = concatenate(
[inception4A_1, inception4A_3, inception4A_5, inception4APoolProj], 1)
#Inception 4B
inception4B_1 = Conv2D(160, 1, 1, padding='same',
activation='relu')(inception4AMerged)
inception4B_3_reduce = Conv2D(112, 1, 1, padding='same',
activation='relu')(inception4AMerged)
inception4B_3 = Conv2D(224, 3, 3, padding='same',
activation='relu')(inception4B_3_reduce)
inception4B_5_reduce = Conv2D(24, 1, 1, padding='same',
activation='relu')(inception4AMerged)
inception4B_5 = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4B_5_reduce)
inception4BPool = MaxPooling2D(3, 1, padding='same')(inception4AMerged)
inception4BPoolProj = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4BPool)
inception4BMerged = concatenate(
[inception4B_1, inception4B_3, inception4B_5, inception4BPoolProj], 1)
#Inception 4C
inception4C_1 = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception4BMerged)
inception4C_3_reduce = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception4BMerged)
inception4C_3 = Conv2D(256, 3, 3, padding='same',
activation='relu')(inception4C_3_reduce)
inception4C_5_reduce = Conv2D(24, 1, 1, padding='same',
activation='relu')(inception4BMerged)
inception4C_5 = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4C_5_reduce)
inception4CPool = MaxPooling2D(3, 1, padding='same')(inception4BMerged)
inception4CPoolProj = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4CPool)
inception4CMerged = concatenate(
[inception4C_1, inception4C_3, inception4C_5, inception4CPoolProj], 1)
#Inception 4D
inception4D_1 = Conv2D(112, 1, 1, padding='same',
activation='relu')(inception4CMerged)
inception4D_3_reduce = Conv2D(144, 1, 1, padding='same',
activation='relu')(inception4CMerged)
inception4D_3 = Conv2D(288, 3, 3, padding='same',
activation='relu')(inception4D_3_reduce)
inception4D_5_reduce = Conv2D(32, 1, 1, padding='same',
activation='relu')(inception4CMerged)
inception4D_5 = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4D_5_reduce)
inception4DPool = MaxPooling2D(3, 1, padding='same')(inception4CMerged)
inception4DPoolProj = Conv2D(64, 1, 1, padding='same',
activation='relu')(inception4DPool)
inception4DMerged = concatenate(
[inception4D_1, inception4D_3, inception4D_5, inception4DPoolProj], 1)
#Inception 4E
inception4E_1 = Conv2D(256, 1, 1, padding='same',
activation='relu')(inception4DMerged)
inception4E_3_reduce = Conv2D(160, 1, 1, padding='same',
activation='relu')(inception4DMerged)
inception4E_3 = Conv2D(320, 3, 3, padding='same',
activation='relu')(inception4E_3_reduce)
inception4E_5_reduce = Conv2D(32, 1, 1, padding='same',
activation='relu')(inception4DMerged)
inception4E_5 = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception4E_5_reduce)
inception4EPool = MaxPooling2D(3, 1, padding='same')(inception4DMerged)
inception4EPoolProj = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception4EPool)
inception4EMerged = concatenate(
[inception4E_1, inception4E_3, inception4E_5, inception4EPoolProj], 1)
#Max pool
pool4 = MaxPooling2D(3, 2, padding='same',
data_format=None)(inception4EMerged)
#Inception5A
inception5A_1 = Conv2D(256, 1, 1, padding='same', activation='relu')(pool4)
inception5A_3_reduce = Conv2D(160, 1, 1, padding='same',
activation='relu')(pool4)
inception5A_3 = Conv2D(320, 3, 3, padding='same',
activation='relu')(inception5A_3_reduce)
inception5A_5_reduce = Conv2D(32, 1, 1, padding='same',
activation='relu')(pool4)
inception5A_5 = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception5A_5_reduce)
inception5APool = MaxPooling2D(3, 1, padding='same')(pool4)
inception5APoolProj = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception5APool)
inception5AMerged = concatenate(
[inception5A_1, inception5A_3, inception5A_5, inception5APoolProj], 1)
#Inception5B
inception5B_1 = Conv2D(384, 1, 1, padding='same',
activation='relu')(inception5AMerged)
inception5B_3_reduce = Conv2D(192, 1, 1, padding='same',
activation='relu')(inception5AMerged)
inception5B_3 = Conv2D(384, 3, 3, padding='same',
activation='relu')(inception5B_3_reduce)
inception5B_5_reduce = Conv2D(48, 1, 1, padding='same',
activation='relu')(inception5AMerged)
inception5B_5 = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception5B_5_reduce)
inception5BPool = MaxPooling2D(3, 1, padding='same')(inception5AMerged)
inception5BPoolProj = Conv2D(128, 1, 1, padding='same',
activation='relu')(inception5BPool)
inception5BMerged = concatenate(
[inception5B_1, inception5B_3, inception5B_5, inception5BPoolProj], 1)
#Average pooling layer
avgPool = AveragePooling2D(pool_size=(7, 7),
strides=1,
padding='same',
data_format=None)(inception5BMerged)
#Dropout
droppedOut = Dropout(0.40)(avgPool)
#Linear
linearLayer = linear()(droppedOut)
#Softmax
lastSoftMax = Softmax()(linearLayer)
#Now we declare the model
googleNet = Model(input=input,
output=[
loss1_classifier_act, loss2_classifier_act,
loss3_classifier_act
])
def get_inception_resnet_v2_unet(input_shape, weights='imagenet'):
inp = Input(input_shape + (9,))
# Stem block: 35 x 35 x 192
x = conv2d_bn(inp, 32, 3, strides=2, padding='same')
x = conv2d_bn(x, 32, 3, padding='same')
x = conv2d_bn(x, 64, 3)
conv1 = x
x = MaxPooling2D(3, strides=2, padding='same')(x)
x = conv2d_bn(x, 80, 1, padding='same')
x = conv2d_bn(x, 192, 3, padding='same')
conv2 = x
x = MaxPooling2D(3, strides=2, padding='same')(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 = 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 K.image_data_format() == 'channels_first' else 3
x = 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)
conv3 = x
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='same')
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='same')
branch_pool = MaxPooling2D(3, strides=2, padding='same')(x)
branches = [branch_0, branch_1, branch_pool]
x = 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)
conv4 = x
# 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='same')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='same')
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='same')
branch_pool = MaxPooling2D(3, strides=2, padding='same')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = 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')
conv5 = x
up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1)
conv6 = conv_block(up6, 128)
conv6 = conv_block(conv6, 128)
up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1)
conv7 = conv_block(up7, 96)
conv7 = conv_block(conv7, 96)
up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1)
conv8 = conv_block(up8, 64)
conv8 = conv_block(conv8, 64)
up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1)
conv9 = conv_block(up9, 48)
conv9 = conv_block(conv9, 48)
up10 = concatenate([UpSampling2D()(conv9), inp], axis=-1)
conv10 = conv_block(up10, 32)
conv10 = conv_block(conv10, 32)
# conv10 = SpatialDropout2D(0.33)(conv10)
res = Conv2D(1, (1, 1), activation='sigmoid')(conv10)
model = Model(inp, res)
if weights == 'imagenet':
inception_resnet_v2 = InceptionResNetV2(weights=weights, include_top=False, input_shape=input_shape + (3,))
for i in range(2, len(inception_resnet_v2.layers)-1):
model.layers[i].set_weights(inception_resnet_v2.layers[i].get_weights())
model.layers[i].trainable = False
return model
def train_a_model(trainfile):
'''
:param trainfile:
:return:
'''
#load the dataset using pandas
data = pd.read_csv(trainfile)
#check len of rows and its intance len
with open(trainfile) as f:
content = f.readlines()
lines = np.array(content)
num_of_instances = lines.size
print("number of instances: ", num_of_instances)
#save the data in train and validation data
x_train, y_train = [], []
for i in range(1, num_of_instances):
try:
emotion = lines[i].split(",")[0]
val = lines[i].split(",")[1:]
pixels = np.array(val, 'float32')
y_train.append(emotion)
x_train.append(pixels)
except:
print("", end="")
# data transformation for train and test sets
x_train = np.array(x_train, 'float32')
x_train /= 255 #normalize inputs between [0, 1]
x_train = x_train.reshape(x_train.shape[0], 48, 48, 1)
x_train = x_train.astype('float32')
print(x_train.shape[0], 'train samples')
y_train = []
for i in range(1, num_of_instances):
try:
emotion = lines[i].split(",")[0]
y_train.append(emotion)
except:
print("", end="")
le = LabelEncoder()
y_train = le.fit_transform(y_train)
a_train = []
for i in range(1, num_of_instances):
emotion = y_train[i - 1]
emotion = keras.utils.to_categorical(emotion, 3)
a_train.append(emotion)
y_train = a_train
y_train = np.array(y_train, 'float32')
#variables
num_classes = 3
#fear, happy, sad
batch_size = 256
epochs = 10
#construct CNN structure
model = Sequential()
#1st convolution layer
model.add(Conv2D(64, (5, 5), activation='relu', input_shape=(48, 48, 1)))
model.add(MaxPooling2D(pool_size=(5, 5), strides=(2, 2)))
#2nd convolution layer
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
#3rd convolution layer
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Flatten())
#fully connected neural networks
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.2))
#-----------------------------
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.3))
#-----------------------------
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes, activation='softmax'))
################################
#------------------------------
#batch process
gen = ImageDataGenerator()
train_generator = gen.flow(x_train, y_train, batch_size=batch_size)
#------------------------------
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
#------------------------------
print('Training start please wait....')
#model.fit_generator(x_train, y_train, epochs=epochs) #train for all trainset
model.fit_generator(train_generator,
steps_per_epoch=batch_size,
epochs=epochs) #train for randomly selected one
print("model Training completed")
model.save('models.h5')
return model
F1 = 8
block1 = (Conv2D(F1, (1, kernLength),
padding='same',
input_shape=(Xall[train].shape[1], Xall[train].shape[0],
1),
use_bias=False))(input1)
block1 = BatchNormalization(axis=1)(block1)
block1 = DepthwiseConv2D((Xall.shape[1], 1),
use_bias=False,
padding='same',
depth_multiplier=2,
depthwise_constraint=max_norm(1.),
data_format='channels_first')(block1)
block1 = BatchNormalization(axis=1)(block1)
block1 = Activation('elu')(block1)
block1 = AveragePooling2D((1, 4), data_format='channels_first')(block1)
block1 = Dropout(dropoutRate)(block1)
block2 = SeparableConv2D(16, (1, 16),
use_bias=False,
padding='same',
data_format='channels_first')(block1)
block2 = BatchNormalization(axis=1)(block2)
block2 = Activation('elu')(block2)
block2 = AveragePooling2D((1, 8),
data_format='channels_first',
padding='same')(block2)
block2 = Dropout(dropoutRate)(block2)
flatten = Flatten(name='flatten')(block2)
dense = Dense(nbClasses,
name='dense',
kernel_constraint=max_norm(normRate))(flatten)
def train(batchsize, epochs, l_nodes, l_dropout, l_rate, momentum,
modules_to_drop, l_decay):
model_name = 'ResNet50_FC_Ep_' + str(epochs) + '_N_' + str(
l_nodes) + '_Decay_' + str(l_decay) + '_LR_' + str(
l_rate) + '_DO_' + str(l_dropout) + '_'
print("Training:", model_name)
datagen = image.ImageDataGenerator(
preprocessing_function=imagenet_utils.preprocess_input,
horizontal_flip=True,
shear_range=0.15,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2)
train_generator = datagen.flow_from_directory(PATH_TRAIN,
batch_size=batchsize,
target_size=target_size)
test_generator = datagen.flow_from_directory(PATH_TEST,
batch_size=batchsize,
target_size=target_size)
num_train = train_generator.n
num_test = test_generator.n
if modules_to_drop == 0:
layers_to_drop = 0
elif modules_to_drop == 1:
layers_to_drop = 11
elif modules_to_drop == 2:
layers_to_drop = 21
elif modules_to_drop == 3:
layers_to_drop = 10
input_tensor = Input(shape=(224, 224, 3))
base_model = inception_v3.InceptionV3(include_top=False,
weights='imagenet',
input_tensor=input_tensor)
# To keep trainable last conv module use :147
for layer in base_model.layers[:20]:
layer.trainable = False
for i in range(layers_to_drop):
base_model.layers.pop()
base_model.outputs = [base_model.layers[-1].output]
base_model.layers[-1].outbound_nodes = []
x = base_model.layers[-1].output
x_fc = AveragePooling2D((4, 4), strides=(8, 8), name='avg_pool')(x)
#x = Dense(l_nodes, activation='relu', kernel_regularizer=regularizers.l2(0.1))(x)
#x = K.reshape(x,(1,-1,l_nodes,1))
#x = Conv2D(10,3,activation='relu',padding='same',kernel_regularizer=regularizers.l2(0.1))(x)
#x = GlobalAveragePooling2D()(x)
#x = Dense(l_nodes, activation='relu', kernel_regularizer=regularizers.l2(0.1))(x)
#x = Dense(l_nodes, activation='relu')(x)
x_fc = Flatten(name='flatten')(x_fc)
#x = Dropout(l_dropout)(x)
predictions = Dense(120, activation='softmax', name='predictions')(x_fc)
model = Model(inputs=base_model.input, outputs=predictions)
model.compile(optimizer=optimizers.Adam(lr=l_rate, decay=l_decay),
loss='categorical_crossentropy',
metrics=['acc'])
try:
model.fit_generator(
train_generator,
steps_per_epoch=num_train / batchsize * 2.0,
validation_data=test_generator,
validation_steps=num_test / batchsize,
epochs=epochs,
use_multiprocessing=True,
callbacks=[
callbacks.ModelCheckpoint(filepath=PATH_MODELS + model_name +
'{val_acc:.2f}.hdf5',
monitor='val_acc',
save_best_only=True,
save_weights_only=False),
callbacks.EarlyStopping(monitor='val_loss', patience=3),
],
)
except KeyboardInterrupt:
pass
score, accuracy = model.evaluate_generator(test_generator,
steps=num_test / batchsize,
use_multiprocessing=True)
print("Final Accuracy: {:.2f}%".format(accuracy * 100))
masks = K.concatenate([style_mask, target_mask], axis=0)
# index constants for images and tasks variables
STYLE, TARGET, CONTENT = 0, 1, 2
# build image model, mask model and target
# vgg19 for image model
image_model = vgg19.VGG19(include_top=False, input_tensor=images)
# pooling layers for mask model
mask_input = Input(tensor=masks, shape=(None, None, None), name="mask_input")
x = mask_input
for layer in image_model.layers[1:]:
name = 'mask_%s' % layer.name
if 'conv' in layer.name:
x = AveragePooling2D((3, 3),
strides=(1, 1),
name=name,
border_mode="same")(x)
#x = MaxPooling2D((3, 3), strides = (1, 1), name=name, border_mode="same", )(x)
elif 'pool' in layer.name:
#x = MaxPooling2D((2, 2), name=name)(x)
x = AveragePooling2D((2, 2), name=name)(x)
mask_model = Model(mask_input, x)
# collect features from image_model and task_model
image_features = {}
mask_features = {}
for img_layer, mask_layer in zip(image_model.layers, mask_model.layers):
if 'conv' in img_layer.name:
assert 'mask_' + img_layer.name == mask_layer.name
layer_name = img_layer.name
img_feat, mask_feat = img_layer.output, mask_layer.output
image_features[layer_name] = img_feat
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid'))
#13x13x512
model.add(Conv2D(1024, (1, 1), padding='same', activation='relu'))
model.add(Conv2D(1024, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(1024, (5, 5), padding='same', activation='relu'))
#model.add(Conv2D(2048, (7,7), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid'))
#6x6x1024
model.add(Conv2D(1256, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(1256, (1, 1), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='valid'))
#2x2x1256
model.add(AveragePooling2D(pool_size=(2, 2), strides=(1, 1), padding='valid'))
#1x1x1256
model.add(Flatten())
#model.add(Dense(4096, activation='relu', use_bias=True))
model.add(Dense(628, activation='relu', use_bias=True))
model.add(Dense(314, activation='relu', use_bias=True))
model.add(Dense(5, activation='softmax', use_bias=True))
print("Model created!!")
model.summary()
print("\nCompiling model...")
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
sgd = SGD(momentum=0.9, nesterov=True, lr=0.003)
def ResNet50(input_shape = (64, 64, 3), classes = 6):
"""
Implementation of the popular ResNet50 the following architecture:
CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3
-> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER
Arguments:
input_shape -- shape of the images of the dataset
classes -- integer, number of classes
Returns:
model -- a Model() instance in Keras
"""
# Define the input as a tensor with shape input_shape
X_input = Input(input_shape)
# Zero-Padding
X = ZeroPadding2D((3, 3))(X_input)
# Stage 1
X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1', kernel_initializer = glorot_uniform(seed=0))(X)
X = BatchNormalization(axis = 3, name = 'bn_conv1')(X)
X = Activation('relu')(X)
X = MaxPooling2D((3, 3), strides=(2, 2))(X)
# Stage 2
X = convolutional_block(X, f = 3, filters = [64, 64, 256], stage = 2, block='a', s = 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')
### START CODE HERE ###
# Stage 3 (≈4 lines)
s=2
f=3
filters = [128,128,512]
stage=3
X = convolutional_block(X, f, filters, stage, block='a', s=2)
X = identity_block(X, f, filters, stage, block='b')
X = identity_block(X, f, filters, stage, block='c')
X = identity_block(X, f, filters, stage, block='d')
# Stage 4 (≈6 lines)
filters = [256, 256, 1024]
stage=4
X = convolutional_block(X, f, filters, stage, block='a', s=2)
X = identity_block(X, f, filters, stage, block='b')
X = identity_block(X, f, filters, stage, block='c')
X = identity_block(X, f, filters, stage, block='d')
X = identity_block(X, f, filters, stage, block='e')
X = identity_block(X, f, filters, stage, block='f')
# Stage 5 (≈3 lines)
filters = [512, 512, 2048]
stage=5
X = convolutional_block(X, f, filters, stage, block='a', s=2)
X = identity_block(X, f, filters, stage, block='b')
X = identity_block(X, f, filters, stage, block='c')
# AVGPOOL (≈1 line). Use "X = AveragePooling2D(...)(X)"
X = AveragePooling2D(pool_size=(2, 2), padding='same')(X)
### END CODE HERE ###
# output layer
X = Flatten()(X)
X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X)
# Create model
model = Model(inputs = X_input, outputs = X, name='ResNet50')
return model
def build_resnet_model(params):
conv1_ksize = params['filters_1']
conv1_nfilter = params['filters']
kernel_size_1 = params['repetitions_1']
kernel_size_2 = params['repetitions_3']
kernel_size_3 = params['repetitions_5']
kernel_size_4 = params['repetitions_7']
num_filter_1 = params['filters_2']
num_filter_2 = params['filters_3']
num_filter_3 = params['filters_4']
num_filter_4 = params['filters_5']
reps_1 = params['repetitions']
reps_2 = params['repetitions_2']
reps_3 = params['repetitions_4']
reps_4 = params['repetitions_6']
conv2_nfilter = params['filters_6']
regularized_coff_1 = params['l2']
regularized_coff_2 = params['l2_1']
regularized_coff_3 = params['l2_2']
learning_rate = params['l2_3']
input_shape = params['input_shape']
ts = input_shape[1]
tickers = input_shape[0]
input = Input(shape=input_shape)
conv1 = conv_bn_relu(filters=conv1_nfilter,kernel_size=(1,conv1_ksize),strides=(1,1),\
kernel_regularizer=regularizers.l2(regularized_coff_1)) (input)
pool1 = MaxPooling2D(pool_size=(1, 3), strides=(1, 2),
padding="same")(conv1)
out = residual_block(filters=num_filter_1, repetitions=reps_1 ,kernel_size=(1,kernel_size_1),\
strides=(1,2),is_first_layer=True) (pool1)
out = residual_block(filters=num_filter_2, repetitions=reps_2,\
kernel_size=(1,kernel_size_2), strides=(1,2)) (out)
out = residual_block(filters=num_filter_3, repetitions=reps_3,\
kernel_size=(1,kernel_size_3),strides=(1,2)) (out)
out = residual_block(filters=num_filter_4, repetitions=reps_4,\
kernel_size=(1,kernel_size_4),strides=(1,2)) (out)
out = bn_relu(out)
conv2 = conv_bn_relu(filters=conv2_nfilter,kernel_size=(381,1),strides=(1,1),\
kernel_regularizer=regularizers.l2(regularized_coff_2),padding='valid') (out)
out_shape = K.int_shape(conv2)
out = AveragePooling2D(pool_size=(out_shape[1], out_shape[2]),
strides=(1, 1))(conv2)
out = Flatten()(out)
out = Dense(tickers,
kernel_regularizer=regularizers.l2(regularized_coff_3))(out)
out = Activation('sigmoid')(out)
model = Model([input], [out])
optimizer = Adam(lr=learning_rate)
model.compile(loss=sharpe_ratio_loss,
optimizer=optimizer,
metrics=[sharpe_ratio])
return model
