def Deeplabv3(weights='pascal_voc',
input_tensor=None,
input_shape=(512, 512, 3),
classes=2,
backbone='xception',
OS=16,
alpha=1.):
""" Instantiates the Deeplabv3+ architecture
Optionally loads weights pre-trained
on PASCAL VOC. This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
data format `(width, height, channels)`.
# Arguments
weights: one of 'pascal_voc' (pre-trained on pascal voc)
or None (random initialization)
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: shape of input image. format HxWxC
PASCAL VOC model was trained on (512,512,3) images
classes: number of desired classes. If classes != 21,
last layer is initialized randomly
backbone: backbone to use. one of {'xception','mobilenetv2'}
OS: determines input_shape/feature_extractor_output ratio. One of {8,16}.
Used only for xception backbone.
alpha: controls the width of the MobileNetV2 network. This is known as the
width multiplier in the MobileNetV2 paper.
- If `alpha` < 1.0, proportionally decreases the number
of filters in each layer.
- If `alpha` > 1.0, proportionally increases the number
of filters in each layer.
- If `alpha` = 1, default number of filters from the paper
are used at each layer.
Used only for mobilenetv2 backbone
# Returns
A Keras model instance.
# Raises
RuntimeError: If attempting to run this model with a
backend that does not support separable convolutions.
ValueError: in case of invalid argument for `weights` or `backbone`
"""
if not (weights in {'pascal_voc', 'deeplab', None}):
raise ValueError(
'The `weights` argument should be either '
'`None` (random initialization) `deeplab` or `pascal_voc` '
'(pre-trained on PASCAL VOC)')
if K.backend() != 'tensorflow':
raise RuntimeError('The Deeplabv3+ model is only available with '
'the TensorFlow backend.')
if not (backbone in {'xception', 'mobilenetv2'}):
raise ValueError('The `backbone` argument should be either '
'`xception` or `mobilenetv2` ')
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 backbone == 'xception':
if OS == 8:
entry_block3_stride = 1
middle_block_rate = 2 # ! Not mentioned in paper, but required
exit_block_rates = (2, 4)
atrous_rates = (12, 24, 36)
else:
entry_block3_stride = 2
middle_block_rate = 1
exit_block_rates = (1, 2)
atrous_rates = (6, 12, 18)
x = Conv2D(32, (3, 3),
strides=(2, 2),
name='entry_flow_conv1_1',
use_bias=False,
padding='same')(img_input)
x = BatchNormalization(name='entry_flow_conv1_1_BN')(x)
x = Activation('relu')(x)
x = _conv2d_same(x, 64, 'entry_flow_conv1_2', kernel_size=3, stride=1)
x = BatchNormalization(name='entry_flow_conv1_2_BN')(x)
x = Activation('relu')(x)
x = _xception_block(x, [128, 128, 128],
'entry_flow_block1',
skip_connection_type='conv',
stride=2,
depth_activation=False)
x, skip1 = _xception_block(x, [256, 256, 256],
'entry_flow_block2',
skip_connection_type='conv',
stride=2,
depth_activation=False,
return_skip=True)
x = _xception_block(x, [728, 728, 728],
'entry_flow_block3',
skip_connection_type='conv',
stride=entry_block3_stride,
depth_activation=False)
for i in range(16):
x = _xception_block(x, [728, 728, 728],
'middle_flow_unit_{}'.format(i + 1),
skip_connection_type='sum',
stride=1,
rate=middle_block_rate,
depth_activation=False)
x = _xception_block(x, [728, 1024, 1024],
'exit_flow_block1',
skip_connection_type='conv',
stride=1,
rate=exit_block_rates[0],
depth_activation=False)
x = _xception_block(x, [1536, 1536, 2048],
'exit_flow_block2',
skip_connection_type='none',
stride=1,
rate=exit_block_rates[1],
depth_activation=True)
else:
OS = 8
first_block_filters = _make_divisible(32 * alpha, 8)
x = Conv2D(first_block_filters,
kernel_size=3,
strides=(2, 2),
padding='same',
use_bias=False,
name='Conv')(img_input)
x = BatchNormalization(epsilon=1e-3, momentum=0.999, name='Conv_BN')(x)
x = Activation(relu6, name='Conv_Relu6')(x)
x = _inverted_res_block(x,
filters=16,
alpha=alpha,
stride=1,
expansion=1,
block_id=0,
skip_connection=False)
x = _inverted_res_block(x,
filters=24,
alpha=alpha,
stride=2,
expansion=6,
block_id=1,
skip_connection=False)
x = _inverted_res_block(x,
filters=24,
alpha=alpha,
stride=1,
expansion=6,
block_id=2,
skip_connection=True)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=2,
expansion=6,
block_id=3,
skip_connection=False)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=1,
expansion=6,
block_id=4,
skip_connection=True)
x = _inverted_res_block(x,
filters=32,
alpha=alpha,
stride=1,
expansion=6,
block_id=5,
skip_connection=True)
# stride in block 6 changed from 2 -> 1, so we need to use rate = 2
x = _inverted_res_block(
x,
filters=64,
alpha=alpha,
stride=1, # 1!
expansion=6,
block_id=6,
skip_connection=False)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
rate=2,
expansion=6,
block_id=7,
skip_connection=True)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
rate=2,
expansion=6,
block_id=8,
skip_connection=True)
x = _inverted_res_block(x,
filters=64,
alpha=alpha,
stride=1,
rate=2,
expansion=6,
block_id=9,
skip_connection=True)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
rate=2,
expansion=6,
block_id=10,
skip_connection=False)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
rate=2,
expansion=6,
block_id=11,
skip_connection=True)
x = _inverted_res_block(x,
filters=96,
alpha=alpha,
stride=1,
rate=2,
expansion=6,
block_id=12,
skip_connection=True)
x = _inverted_res_block(
x,
filters=160,
alpha=alpha,
stride=1,
rate=2, # 1!
expansion=6,
block_id=13,
skip_connection=False)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=1,
rate=4,
expansion=6,
block_id=14,
skip_connection=True)
x = _inverted_res_block(x,
filters=160,
alpha=alpha,
stride=1,
rate=4,
expansion=6,
block_id=15,
skip_connection=True)
x = _inverted_res_block(x,
filters=320,
alpha=alpha,
stride=1,
rate=4,
expansion=6,
block_id=16,
skip_connection=False)
# end of feature extractor
# branching for Atrous Spatial Pyramid Pooling
# Image Feature branch
#out_shape = int(np.ceil(input_shape[0] / OS))
b4 = AveragePooling2D(pool_size=(int(np.ceil(input_shape[0] / OS)),
int(np.ceil(input_shape[1] / OS))))(x)
b4 = Conv2D(256, (1, 1),
padding='same',
use_bias=False,
name='image_pooling')(b4)
b4 = BatchNormalization(name='image_pooling_BN', epsilon=1e-5)(b4)
b4 = Activation('relu')(b4)
b4 = BilinearUpsampling((int(np.ceil(input_shape[0] / OS)),
int(np.ceil(input_shape[1] / OS))))(b4)
# simple 1x1
b0 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='aspp0')(x)
b0 = BatchNormalization(name='aspp0_BN', epsilon=1e-5)(b0)
b0 = Activation('relu', name='aspp0_activation')(b0)
# there are only 2 branches in mobilenetV2. not sure why
if backbone == 'xception':
# rate = 6 (12)
b1 = SepConv_BN(x,
256,
'aspp1',
rate=atrous_rates[0],
depth_activation=True,
epsilon=1e-5)
# rate = 12 (24)
b2 = SepConv_BN(x,
256,
'aspp2',
rate=atrous_rates[1],
depth_activation=True,
epsilon=1e-5)
# rate = 18 (36)
b3 = SepConv_BN(x,
256,
'aspp3',
rate=atrous_rates[2],
depth_activation=True,
epsilon=1e-5)
# concatenate ASPP branches & project
x = Concatenate()([b4, b0, b1, b2, b3])
else:
x = Concatenate()([b4, b0])
x = Conv2D(256, (1, 1),
padding='same',
use_bias=False,
name='concat_projection')(x)
x = BatchNormalization(name='concat_projection_BN', epsilon=1e-5)(x)
x = Activation('relu')(x)
x = Dropout(0.1)(x)
# DeepLab v.3+ decoder
if backbone == 'xception':
# Feature projection
# x4 (x2) block
x = BilinearUpsampling(output_size=(int(np.ceil(input_shape[0] / 4)),
int(np.ceil(input_shape[1] /
4))))(x)
dec_skip1 = Conv2D(48, (1, 1),
padding='same',
use_bias=False,
name='feature_projection0')(skip1)
dec_skip1 = BatchNormalization(name='feature_projection0_BN',
epsilon=1e-5)(dec_skip1)
dec_skip1 = Activation('relu')(dec_skip1)
x = Concatenate()([x, dec_skip1])
x = SepConv_BN(x,
256,
'decoder_conv0',
depth_activation=True,
epsilon=1e-5)
x = SepConv_BN(x,
256,
'decoder_conv1',
depth_activation=True,
epsilon=1e-5)
# you can use it with arbitary number of classes
if classes == 21:
last_layer_name = 'logits_semantic'
else:
last_layer_name = 'custom_logits_semantic'
# x = Conv2D(classes, (1, 1), padding='same', name=last_layer_name)(x)
# x = BilinearUpsampling(output_size=(input_shape[0], input_shape[1]))(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
weight_decay = 5e-4,
x = GlobalAveragePooling2D()(x)
x = Dense(classes,
use_bias=False,
kernel_regularizer=l2(weight_decay),
kernel_initializer='he_normal',
activation='softmax')(x)
model = Model(inputs, x, name='deeplabv3+')
# load weights
if weights == 'pascal_voc':
if backbone == 'xception':
weights_path = get_file(
'deeplabv3_xception_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH_X,
cache_subdir='models')
else:
weights_path = get_file(
'deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels.h5',
WEIGHTS_PATH_MOBILE,
cache_subdir='models')
model.load_weights(weights_path, by_name=True)
if weights == 'deeplab':
model.load_weights(weights_path_deeplab, by_name=True)
return model
def DenseNet(nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.0,
dropout_rate=0.0,
weight_decay=1e-4,
classes=1000,
weights_path=None,
category_num=6):
'''Instantiate the DenseNet 121 architecture,
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(224, 224, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, 224, 224), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 24, 16] # For DenseNet-121
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x = Dense(classes, name='fc6')(x)
x = Activation('relu', name='prob')(x)
model = Model(img_input, x, name='densenet')
# if weights_path is not None:
# model.load_weights(weights_path)
# for layer in model.layers:
# layer.trainable = False
x = model.output
x = Dense(category_num, name='fc61')(x)
x = Activation('softmax', name='prob1')(x)
model = Model(img_input, x, name='densenet1')
return model
_inputBN = BatchNormalization(axis=-1)(_input)
C1 = ConvSN2D(15, (5, 5), padding='valid',
data_format='channels_last')(_inputBN)
C1 = LeakyReLU()(C1)
C2 = ConvSN2D(25, (7, 7), padding='valid', data_format='channels_last')(C1)
C2 = LeakyReLU()(C2)
C3 = ConvSN2D(40, (9, 9), padding='valid', data_format='channels_last')(C2)
C3 = LeakyReLU()(C3)
C4 = ConvSN2D(50, (11, 11), padding='valid', data_format='channels_last')(C3)
C4 = LeakyReLU()(C4)
Average_score = GlobalAveragePooling2D(name='Average_score')(
C4) #(batch_size, channels)
D1 = DenseSN(50)(Average_score)
D1 = LeakyReLU()(D1)
D2 = DenseSN(10)(D1)
D2 = LeakyReLU()(D2)
Score = DenseSN(1)(D2)
Discriminator = Model(outputs=Score, inputs=_input)
Discriminator.trainable = True
Discriminator.compile(loss='mse', optimizer='adam')
#### Combine the two networks to become MetricGAN
nb_kernels = 2 * nb_kernels
block6 = residual_block(block5, nb_kernels, doPooling=True)
block7 = residual_block(block6, nb_kernels, doPooling=False)
block8 = residual_block(block7, nb_kernels, doPooling=False)
nb_kernels = 2 * nb_kernels
block9 = residual_block(block8, nb_kernels, doPooling=True)
block10 = residual_block(block9, nb_kernels, doPooling=False)
block11 = residual_block(block10, nb_kernels, doPooling=False)
nb_kernels = 2 * nb_kernels
block12 = residual_block(block11, nb_kernels, doPooling=True)
block13 = residual_block(block12, nb_kernels, doPooling=False)
block14 = residual_block(block13, nb_kernels, doPooling=False)
g_avep = GlobalAveragePooling2D()(block14)
g_avep = Dropout(0.3)(g_avep)
output = Dense(2,
kernel_initializer='normal',
kernel_regularizer=regularizers.l2(L2_regularizers))(g_avep)
output = Activation('softmax')(output)
model = Model(inputs=input, outputs=output)
#SGD + momentum
#model.compile provides the cross entropy loss function
sgd = SGD(lr=0.01, decay=1e-7, momentum=0.95, nesterov=True)
model.compile(optimizer=sgd, loss='binary_crossentropy', metrics=['accuracy'])
model.summary()
##################
def create_model(nb_classes, input_shape, config=None):
"""Create a VGG-16 like model."""
if len(input_shape) != 3:
raise Exception("Input shape should be a tuple (nb_channels, nb_rows, "
"nb_cols) or (nb_rows, nb_cols, nb_channels), "
"depending on your backend.")
if config is None:
config = {'model': {}}
# input_shape = (None, None, 3) # for fcn
input_ = Input(shape=input_shape)
x = input_
min_feature_map_dimension = min(input_shape[:2])
if min_feature_map_dimension < 32:
print("ERROR: Please upsample the feature maps to have at least "
"a size of 32 x 32. Currently, it has {}".format(input_shape))
tmp = min_feature_map_dimension / 32.
nb_filter = 32
if tmp >= 2:
while tmp >= 2.:
y = x
for _ in range(2):
x = Convolution2D(nb_filter / 2, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
y = Convolution2D(nb_filter / 2, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
x = concatenate([x, y], axis=-1)
x = MaxPooling2D(pool_size=(2, 2))(x)
# nb_filter *= 2
tmp /= 2
if 'c1' in config['model']:
c1_nb_filter = config['model']['c1']['nb_filter']
else:
c1_nb_filter = nb_filter
if 'c8' in config['model']:
c8_nb_filter = config['model']['c8']['nb_filter']
else:
c8_nb_filter = 512
y = x
x = Convolution2D(c1_nb_filter / 2, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
y = Convolution2D(c1_nb_filter / 2, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
x = concatenate([x, y], axis=-1)
#
y = x
x = Convolution2D(nb_filter / 2, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
y = Convolution2D(nb_filter / 2, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
x = concatenate([x, y], axis=-1)
#
x = MaxPooling2D(pool_size=(2, 2))(x)
y = x
x = Convolution2D(nb_filter, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
y = Convolution2D(nb_filter, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
x = concatenate([x, y], axis=-1)
#
y = x
x = Convolution2D(nb_filter, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
y = Convolution2D(nb_filter, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
x = concatenate([x, y], axis=-1)
#
x = MaxPooling2D(pool_size=(2, 2))(x)
y = x
x = Convolution2D(nb_filter, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
y = Convolution2D(nb_filter, (3, 3),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
x = concatenate([x, y], axis=-1)
#
x = MaxPooling2D(pool_size=(2, 2))(x)
y = x
x = Convolution2D(256, (4, 4),
padding='valid',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Dropout(0.5)(x)
y = Convolution2D(256, (4, 4),
padding='valid',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(y)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = Dropout(0.5)(y)
x = concatenate([x, y], axis=-1)
#
y = x
x = Convolution2D(c8_nb_filter / 2, (1, 1),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Dropout(0.5)(x)
y = Convolution2D(c8_nb_filter / 2, (1, 1),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
y = BatchNormalization()(y)
y = Activation('relu')(y)
y = Dropout(0.5)(y)
x = concatenate([x, y], axis=-1)
#
x = Convolution2D(nb_classes, (1, 1),
padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = GlobalAveragePooling2D()(x) # Adjust for FCN
x = BatchNormalization()(x)
x = Activation('softmax')(x)
model = Model(inputs=input_, outputs=x)
return model
def create_dense_net(nb_classes,
img_dim,
depth=40,
nb_dense_block=3,
growth_rate=12,
nb_filter=-1,
bottleneck=False,
reduction=0.0,
dropout_rate=None,
weight_decay=1E-4,
verbose=True):
''' Build the create_dense_net model
Args:
nb_classes: number of classes
img_dim: tuple of shape (channels, rows, columns) or (rows, columns, channels)
depth: number or layers
nb_dense_block: number of dense blocks to add to end (generally = 3)
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters. Default -1 indicates initial number of filters is 2 * growth_rate
bottleneck: add bottleneck blocks
reduction: reduction factor of transition blocks. Note : reduction value is inverted to compute compression
dropout_rate: dropout rate
weight_decay: weight decay
verbose: print the model type
Returns: keras tensor with nb_layers of conv_block appended
'''
model_input = Input(shape=img_dim)
concat_axis = 1 if K.image_dim_ordering() == "th" else -1
assert (depth - 4) % 3 == 0, "Depth must be 3 N + 4"
if reduction != 0.0:
assert reduction <= 1.0 and reduction > 0.0, "reduction value must lie between 0.0 and 1.0"
# layers in each dense block
nb_layers = int((depth - 4) / 3)
if bottleneck:
nb_layers = int(nb_layers // 2)
# compute initial nb_filter if -1, else accept users initial nb_filter
if nb_filter <= 0:
nb_filter = 2 * growth_rate
# compute compression factor
compression = 1.0 - reduction
# Initial convolution
x = Convolution2D(nb_filter,
3,
3,
init="he_uniform",
border_mode="same",
name="initial_conv2D",
bias=False,
W_regularizer=l2(weight_decay))(model_input)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
x, nb_filter = dense_block(x,
nb_layers,
nb_filter,
growth_rate,
bottleneck=bottleneck,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# add transition_block
x = transition_block(x,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
# The last dense_block does not have a transition_block
x, nb_filter = dense_block(x,
nb_layers,
nb_filter,
growth_rate,
bottleneck=bottleneck,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(mode=0,
axis=concat_axis,
gamma_regularizer=l2(weight_decay),
beta_regularizer=l2(weight_decay))(x)
x = Activation('relu')(x)
x = GlobalAveragePooling2D()(x)
x = Dense(nb_classes,
activation='softmax',
W_regularizer=l2(weight_decay),
b_regularizer=l2(weight_decay))(x)
densenet = Model(input=model_input, output=x, name="create_dense_net")
if verbose:
if bottleneck and not reduction:
print("Bottleneck DenseNet-B-%d-%d created." %
(depth, growth_rate))
elif not bottleneck and reduction > 0.0:
print("DenseNet-C-%d-%d with %0.1f compression created." %
(depth, growth_rate, compression))
elif bottleneck and reduction > 0.0:
print(
"Bottleneck DenseNet-BC-%d-%d with %0.1f compression created."
% (depth, growth_rate, compression))
else:
print("DenseNet-%d-%d created." % (depth, growth_rate))
return densenet
def create_model(img_rows=224,
img_cols=224,
color_type=3,
nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.5,
dropout_rate=0.0,
weight_decay=1e-4):
'''
DenseNet 169 Model for Keras
Model Schema is based on
https://github.com/flyyufelix/DenseNet-Keras
ImageNet Pretrained Weights
Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfN0d3T1F1MXg0NlU
TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfSEc5UC1ROUFJdmM
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras models instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
concat_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 32, 32] # For DenseNet-169
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
return model, x, final_stage, img_input
def __create_dense_net(nb_classes, img_input, include_top, depth=40, nb_dense_block=3, growth_rate=12, nb_filter=-1,
nb_layers_per_block=-1, bottleneck=False, reduction=0.0, dropout_rate=None, weight_decay=1e-4,
subsample_initial_block=False, activation='softmax'):
concat_axis = 1 if K.image_data_format() == 'channels_first' else -1
if reduction != 0.0:
assert 1.0 >= reduction > 0.0, 'reduction value must lie between 0.0 and 1.0'
# layers in each dense block
if type(nb_layers_per_block) is list or type(nb_layers_per_block) is tuple:
nb_layers = list(nb_layers_per_block) # Convert tuple to list
assert len(nb_layers) == nb_dense_block, 'If list, nb_layer is used as provided. ' \
'Note that list size must be (nb_dense_block)'
final_nb_layer = nb_layers[-1]
nb_layers = nb_layers[:-1]
else:
if nb_layers_per_block == -1:
assert (depth - 4) % 3 == 0, 'Depth must be 3 N + 4 if nb_layers_per_block == -1'
count = int((depth - 4) / 3)
if bottleneck:
count = count // 2
nb_layers = [count for _ in range(nb_dense_block)]
final_nb_layer = count
else:
final_nb_layer = nb_layers_per_block
nb_layers = [nb_layers_per_block] * nb_dense_block
# compute initial nb_filter if -1, else accept users initial nb_filter
if nb_filter <= 0:
nb_filter = 2 * growth_rate
# compute compression factor
compression = 1.0 - reduction
# Initial convolution
if subsample_initial_block:
initial_kernel = (7, 7)
initial_strides = (2, 2)
else:
initial_kernel = (3, 3)
initial_strides = (1, 1)
x = Conv2D(nb_filter, initial_kernel, kernel_initializer='he_normal', padding='same',
strides=initial_strides, use_bias=False, kernel_regularizer=l2(weight_decay))(img_input)
if subsample_initial_block:
x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
x, nb_filter = __dense_block(x, nb_layers[block_idx], nb_filter, growth_rate, bottleneck=bottleneck,
dropout_rate=dropout_rate, weight_decay=weight_decay)
# add transition_block
x = __transition_block(x, nb_filter, compression=compression, weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
# The last dense_block does not have a transition_block
x, nb_filter = __dense_block(x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck,
dropout_rate=dropout_rate, weight_decay=weight_decay)
x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(x)
x = Activation('relu')(x)
x = GlobalAveragePooling2D()(x)
if include_top:
x = Dense(nb_classes, activation=activation)(x)
return x
def __create_dense_net(nb_classes, img_input, include_top, depth=40, nb_dense_block=3, growth_rate=12, nb_filter=-1,
nb_layers_per_block=-1, bottleneck=False, reduction=0.0, dropout_rate=None, weight_decay=1E-4):
''' Build the DenseNet model
Args:
nb_classes: number of classes
img_input: tuple of shape (channels, rows, columns) or (rows, columns, channels)
include_top: flag to include the final Dense layer
depth: number or layers
nb_dense_block: number of dense blocks to add to end (generally = 3)
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters. Default -1 indicates initial number of filters is 2 * growth_rate
nb_layers_per_block: number of layers in each dense block.
Can be a -1, positive integer or a list.
If -1, calculates nb_layer_per_block from the depth of the network.
If positive integer, a set number of layers per dense block.
If list, nb_layer is used as provided. Note that list size must
be (nb_dense_block + 1)
bottleneck: add bottleneck blocks
reduction: reduction factor of transition blocks. Note : reduction value is inverted to compute compression
dropout_rate: dropout rate
weight_decay: weight decay
Returns: keras tensor with nb_layers of conv_block appended
'''
concat_axis = 1 if K.image_dim_ordering() == "th" else -1
assert (depth - 4) % 3 == 0, "Depth must be 3 N + 4"
if reduction != 0.0:
assert reduction <= 1.0 and reduction > 0.0, "reduction value must lie between 0.0 and 1.0"
# layers in each dense block
if type(nb_layers_per_block) is list or type(nb_layers_per_block) is tuple:
nb_layers = list(nb_layers_per_block) # Convert tuple to list
assert len(nb_layers) == (nb_dense_block + 1), "If list, nb_layer is used as provided. " \
"Note that list size must be (nb_dense_block + 1)"
final_nb_layer = nb_layers[-1]
nb_layers = nb_layers[:-1]
else:
if nb_layers_per_block == -1:
count = int((depth - 4) / 3)
nb_layers = [count for _ in range(nb_dense_block)]
final_nb_layer = count
else:
final_nb_layer = nb_layers_per_block
nb_layers = [nb_layers_per_block] * nb_dense_block
if bottleneck:
nb_layers = [int(layer // 2) for layer in nb_layers]
# compute initial nb_filter if -1, else accept users initial nb_filter
if nb_filter <= 0:
nb_filter = 2 * growth_rate
# compute compression factor
compression = 1.0 - reduction
# Initial convolution
x = Conv2D(nb_filter, (3, 3), kernel_initializer="he_uniform", padding="same", name="initial_conv2D", use_bias=False,
kernel_regularizer=l2(weight_decay))(img_input)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
x, nb_filter = __dense_block(x, nb_layers[block_idx], nb_filter, growth_rate, bottleneck=bottleneck,
dropout_rate=dropout_rate, weight_decay=weight_decay)
# add transition_block
x = __transition_block(x, nb_filter, compression=compression, dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
# The last dense_block does not have a transition_block
x, nb_filter = __dense_block(x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck,
dropout_rate=dropout_rate, weight_decay=weight_decay)
x = BatchNormalization(axis=concat_axis, gamma_regularizer=l2(weight_decay),
beta_regularizer=l2(weight_decay))(x)
x = Activation('relu')(x)
x = GlobalAveragePooling2D()(x)
if include_top:
x = Dense(nb_classes, activation='softmax', kernel_regularizer=l2(weight_decay), bias_regularizer=l2(weight_decay))(x)
return x
from keras.models import Sequential
from keras.layers import Dropout, Flatten, Dense
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPooling2D, GlobalAveragePooling2D
model = Sequential()
model.add(
Conv2D(32, 3, padding="same", activation="relu",
input_shape=(180, 180, 3)))
model.add(MaxPooling2D())
model.add(Conv2D(64, 3, padding="same", activation="relu"))
model.add(MaxPooling2D())
model.add(Conv2D(128, 3, padding="same", activation="relu"))
model.add(MaxPooling2D())
model.add(GlobalAveragePooling2D())
model.add(Dense(num_classes, activation="softmax"))
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy"])
model.summary()
# To train the model:
model.fit_generator(
train_gen,
steps_per_epoch=10, #num_train_images // batch_size,
epochs=3,
validation_data=val_gen,
validation_steps=10, #num_val_images // batch_size,
def IceNet(classes=1000,
input_shape=(1, 30, 30, 3),
weights_path=None,
include_top=True,
only_preprocess_fn_needed=False):
if only_preprocess_fn_needed:
return None, preprocess_input_vgg
img_input_1 = Input(shape=input_shape, name='band_1')
# img_input_2 = Input(shape=input_shape,name = 'band_2')
# angle_input = Input(shape=[1],name='inc_angle')
x = residual_block(img_input_1, 64, (1, 3, 3), 1, 1)
x = residual_block(x, 128, (1, 3, 3), 1, 2)
x = residual_block(x, 256, (1, 3, 3), 1, 3)
# y = residual_block(img_input_2,64,(3,3),2,1)
# y = residual_block(y,128,(3,3),2,2)
# y = residual_block(y,256,(3,3),2,3)
# x = Concatenate()([x,y,angle_input])
# x = Concatenate(axis = -1)([x,y])
##x = residual_block(x,512,(3,3),3,1)
# x = residual_block(x,512,(3,3),3,2)
##x = residual_block(x,1024,(3,3),3,3)
x = Conv3D(256, (1, 1, 1), padding='same', name='block%d_conv' % 4)(x)
#x = K.squeeze(x,1)
x = Lambda(lambda z: K.squeeze(z, 1), name='squeeze')(x)
x = GlobalAveragePooling2D(name='avgpool3')(x)
# x = Dense(512,name="fc1")(x)
# x = Activation('relu', name='DenseRelu1')(x)
# x = Dropout(0.1)(x)
# x = Concatenate()([x,angle_input])
# x = L2Norm(alpha = 20, name='L2Norm_Scaled1')(x)
# x = AlphaL2Norm(alpha = 20, name='AlphaL2Norm')(x)
"""x = Dense(256,name="fc1")(x)
x = Activation('relu', name='DenseRelu1')(x)
x = Dropout(0.1)(x)
# x = L2Norm(alpha = 20, name='L2Norm_Scaled2')(x)
# x = L2Norm(alpha = 20, name='L2Norm_Scaled2')(x)
# x = Dense(128,name="fc2")(x)
# x = Activation('relu', name='DenseRelu2')(x)
# x = Dropout(0.2)(x)
x = Dense(classes, name='fc_pred')(x)
# x = Activation('softmax', name='prob')(x)
x = Activation('sigmoid', name='prob')(x)"""
# x = Flatten()(x)
x = Dense(16, name="fc1")(x)
x = Activation('relu', name='DenseRelu1')(x)
x = Dense(16, name="fc2")(x)
x = Activation('relu', name='DenseRelu2')(x)
x = Dense(16, name="fc3")(x)
x = Activation('relu', name='DenseRelu3')(x)
x = Dense(classes, activation='linear')(x)
# model = Model([img_input_1,img_input_2,angle_input], x, name='icenet')
model = Model(img_input_1, x, name='icenet')
return model, preprocess_input_vgg
size = (512, 512)
#Load trainig and validation data
train_X, train_Y, valid_X, valid_Y = loadTrainAndValidationDatasets(size)
input_shape = (512, 512, 3)
#Initialize the base inception model.
base_model = InceptionV3(weights='imagenet',
include_top=False,
input_shape=input_shape)
#Add dense and 8-softmax layer on top for classifying the 8 fish categories
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(8, activation='softmax')(x)
model = Model(input=base_model.input, output=predictions)
#Now make base model untrainable and only train the layers added on top.
for layer in base_model.layers:
layer.trainable = False
#Compile and fit this model
model.compile(optimizer=Adam(lr=0.001),
loss="categorical_crossentropy",
metrics=['accuracy'])
model.fit(x=train_X,
def create_ResNet(nb_classes,
img_dim,
nb_blocks=[4, 4, 4],
k=1,
weight_decay=1E-4,
droprate=0.):
"""
:param nb_classes: the number of your dataset classes,
for cifar-10, nb_classes should be 10
:param img_dim: the input shape of the model input
:param nb_blocks: the number of blocks in each stage
:param k: the widen fatcor, k=1 indicates that the model
is original ResNet, when k>1 the model is a wide ResNet
:param weight_decay: weight decay for L2 regularization
:param droprate: the dropout between two convolutons of
each block and the default drop rate is set to 0.0
:return: ResNet model or WRN model
"""
model_input = Input(shape=img_dim)
stack = [16 * k, 32 * k, 64 * k]
nb_filter = 16
# Initial convolution
y = Conv2D(nb_filter, (3, 3),
kernel_initializer="he_normal",
padding="same",
use_bias=False,
kernel_regularizer=l2(weight_decay))(model_input)
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
x = Activation('relu')(x)
# stage 1
x = residual_block(x, stack[0], dropout_rate=droprate)
if stack[0] != 16:
y = Conv2D(stack[0], (1, 1),
kernel_initializer="he_normal",
padding="same",
use_bias=False,
kernel_regularizer=l2(weight_decay))(y)
y = add([x, y])
for j in range(nb_blocks[0] - 1):
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
x = Activation('relu')(x)
x = residual_block(x, stack[0], dropout_rate=droprate)
y = add([x, y])
# stage 2
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
y = Activation('relu')(x)
x = residual_block(y, stack[1], strides=(2, 2), dropout_rate=droprate)
y = Conv2D(stack[1], (1, 1),
strides=(2, 2),
kernel_initializer="he_normal",
padding="valid",
use_bias=False,
kernel_regularizer=l2(weight_decay))(y)
y = add([x, y])
for j in range(nb_blocks[1] - 1):
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
x = Activation('relu')(x)
x = residual_block(x, stack[1], dropout_rate=droprate)
y = add([x, y])
# stage 3
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
y = Activation('relu')(x)
x = residual_block(y, stack[2], strides=(2, 2), dropout_rate=droprate)
y = Conv2D(stack[2], (1, 1),
strides=(2, 2),
kernel_initializer="he_normal",
padding="valid",
use_bias=False,
kernel_regularizer=l2(weight_decay))(y)
y = add([x, y])
for j in range(nb_blocks[2] - 1):
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
x = Activation('relu')(x)
x = residual_block(x, stack[2], dropout_rate=droprate)
y = add([x, y])
x = BatchNormalization(axis=-1, epsilon=1.1e-5)(y)
x = Activation('relu')(x)
x = GlobalAveragePooling2D()(x)
x = Dense(nb_classes,
activation='softmax',
kernel_regularizer=l2(weight_decay),
bias_regularizer=l2(weight_decay))(x)
model = Model(input=[model_input], output=[x])
return model
def mgcNetArchRes(outLayer, l2_val, **kwargs):
"""
CNN architecture - without maximum pooling (replaced by convolutional layer of stride 2)
Network architecture summary and plot
The output layers, either multiple layer perceptron network or maximum pooling
Return end-to-end network architecture to be compiled and trained
Argumnents:
input_img_rows: horizontal dimension in pixel of input image
input_img_cols:vertical dimension in pixel of input image
channels: number of colour channel
nb_classes: number of unique classification class exist in the dataset target
"""
def_vals = {
"input_img_rows": 72,
"input_img_cols": 72,
"channels": 1,
"nb_classes": 13
} # default parameters value
for k, v in def_vals.items():
kwargs.setdefault(k, v)
input_img_rows = kwargs['input_img_rows']
input_img_cols = kwargs['input_img_cols']
channels = kwargs['channels']
nb_classes = kwargs['nb_classes']
# Input: 72 x 72 x 1
img_shape = layers.Input(shape=(input_img_rows, input_img_cols, channels))
# Layer 1
#------------------------
conv1 = layers.Conv2D(
filters=32,
kernel_size=(2, 2),
padding='same',
kernel_regularizer=regularizers.l2(l2_val))(img_shape)
conv1 = layers.Activation('relu')(conv1)
conv1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv1 = layers.Dropout(0.4)(conv1)
conv1 = residual_block(img_shape,
32,
_strides=(1, 1),
_project_shortcut=False)
# Layer 2
#------------------------
conv2 = residual_block(conv1, 32, _strides=(1, 1), _project_shortcut=False)
# Layer 3
#------------------------
conv3 = residual_block(conv2, 32, _strides=(1, 1), _project_shortcut=False)
# Layer 4
# -----------------------
#residual = residual_block(conv3, 64, _strides=(1, 1), _project_shortcut=False)
# Layer 5
#------------------------
output = layers.Conv2D(filters=128,
kernel_size=(2, 2),
padding='same',
kernel_regularizer=regularizers.l2(l2_val))(
conv3) # skip layer 4
output = layers.Activation('relu')(output)
output = layers.Conv2D(filters=64,
kernel_size=(2, 2),
padding='same',
activation='relu',
strides=2)(output)
output = layers.Dropout(0.4)(output)
# FC Layer
#------------------------
outputmlp = layers.Flatten()(output)
outputmlp = layers.Dense(64, activation='relu')(outputmlp)
outputmlp = layers.Dropout(0.5)(outputmlp)
predictionsMlp = layers.Dense(nb_classes, activation='softmax')(outputmlp)
# global averaging
weight_decay = 1E-4
concat_axis = 1
x = BatchNormalization(
axis=concat_axis,
gamma_regularizer=regularizers.l2(weight_decay),
beta_regularizer=regularizers.l2(weight_decay))(output)
x = Activation('relu')(x)
x = layers.Dropout(0.4)(x)
x = GlobalAveragePooling2D(data_format=K.image_data_format())(x)
predictionsGloAvg = layers.Dense(
nb_classes,
activation='softmax',
kernel_regularizer=regularizers.l2(weight_decay),
bias_regularizer=regularizers.l2(weight_decay))(x)
if outLayer == "gloAvg":
predictions = predictionsGloAvg
elif outLayer == "mlp":
predictions = predictionsMlp
# prediction model
model = Model(img_shape, predictions, name='resblock')
return model
def incepfusionv1(input,
demographics,
dropout_keep_prob=0.8,
num_classes=1000,
is_training=True,
scope='IncepFusionV1'):
'''Creates the IncepFusionV1 network.'''
with tf.variable_scope(scope, 'IncepFusionV1', [input]):
# Input shape is 299 * 299 * 3
x = resnet_v2_stem(input) # Output: 35 * 35 * 256
# 5 x Inception A
for i in range(5):
x = inception_resnet_v2_A(x)
# Output: 35 * 35 * 256
# Reduction A
x = reduction_resnet_A(x, k=256, l=256, m=384,
n=384) # Output: 17 * 17 * 896
# 10 x Inception B
for i in range(10):
x = inception_resnet_v2_B(x)
# Output: 17 * 17 * 896
# auxiliary
loss2_ave_pool = AveragePooling2D(pool_size=(5, 5),
strides=(3, 3),
name='loss2/ave_pool')(x)
loss2_conv_a = Conv2D(128, (1, 1),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(loss2_ave_pool)
loss2_conv_b = Conv2D(768, (5, 5),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(loss2_conv_a)
loss2_conv_b = BatchNormalization(axis=3)(loss2_conv_b)
loss2_conv_b = Activation('relu')(loss2_conv_b)
loss2_flat = Flatten()(loss2_conv_b)
loss2_fc = Dense(1024,
activation='relu',
name='loss2/fc',
kernel_regularizer=l2(0.0002))(loss2_flat)
loss2_drop_fc = Dropout(dropout_keep_prob)(loss2_fc,
training=is_training)
loss2_classifier = Dense(num_classes,
name='loss2/classifier',
kernel_regularizer=l2(0.0002))(loss2_drop_fc)
# Reduction B
x = reduction_resnet_v2_B(x) # Output: 8 * 8 * 1792
# 5 x Inception C
for i in range(5):
x = inception_resnet_v2_C(x)
# Output: 8 * 8 * 1792
net = x
# Average Pooling
x = GlobalAveragePooling2D(name='avg_pool')(x) # Output: 1792
pool5_drop_10x10_s1 = Dropout(dropout_keep_prob)(x,
training=is_training)
demographics = Dense(5,
name='demographic_fc1',
activation="relu",
kernel_regularizer=l2(0.0002))(demographics)
merged = concatenate([pool5_drop_10x10_s1, demographics])
loss3_classifier_W = Dense(num_classes,
name='loss3/classifier',
kernel_regularizer=l2(0.0002))
loss3_classifier = loss3_classifier_W(merged)
w_variables = loss3_classifier_W.get_weights()[0]
logits = tf.cond(
tf.equal(is_training, tf.constant(True)),
lambda: tf.add(loss3_classifier,
tf.scalar_mul(tf.constant(0.3), loss2_classifier)),
lambda: loss3_classifier)
return logits, net, tf.convert_to_tensor(w_variables)
def _build_base_model(self):
model = Sequential()
# section 1
model.add(
Convolution2D(filters=32,
kernel_size=5,
strides=2,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal",
input_shape=(self.n_frames, self.n_bands,
self.n_channels)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(
Convolution2D(filters=32,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.3))
# section 2
model.add(
Convolution2D(filters=64,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(
Convolution2D(filters=64,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.3))
# section 3
model.add(
Convolution2D(filters=128,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(
Convolution2D(filters=128,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(
Convolution2D(filters=128,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(
Convolution2D(filters=128,
kernel_size=3,
strides=1,
padding="same",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.3))
# section 4
model.add(
Convolution2D(filters=512,
kernel_size=3,
strides=1,
padding="valid",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(
Convolution2D(filters=512,
kernel_size=1,
strides=1,
padding="valid",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
# section 5
model.add(
Convolution2D(filters=10,
kernel_size=1,
strides=1,
padding="valid",
kernel_regularizer=l2(0.0001),
kernel_initializer="normal"))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(GlobalAveragePooling2D())
model.add(Activation('softmax'))
# load the saved checkpoint weights
# model.load_weights('/Users/nbip/proj/dtu/dtu-bach/dev/sound_classification_weights.hdf5')
model.load_weights(self.weights_path)
# pop the top layers?
# Try to remove a different number of layers. Removing 2 seems to work okay
# Previous one was model.layers.pop() which did not work
for _ in range(2):
model.pop()
# needed fix, to have an output of the model
model.outputs = [model.layers[-1].output]
model.layers[-1].outbound_nodes = []
return model
def create_model(nb_classes, input_shape, config=None):
"""Create a VGG-16 like model."""
if len(input_shape) != 3:
raise Exception("Input shape should be a tuple (nb_channels, nb_rows, "
"nb_cols) or (nb_rows, nb_cols, nb_channels), "
"depending on your backend.")
if config is None:
config = {'model': {}}
min_feature_map_dimension = min(input_shape[:2])
if min_feature_map_dimension < 32:
print("ERROR: Please upsample the feature maps to have at least "
"a size of 32 x 32. Currently, it has {}".format(input_shape))
nb_filter = 32
# Network definition
# input_shape = (None, None, 3) # for fcn
input_ = Input(shape=input_shape)
x = input_
# Scale feature maps down to [63, 32] x [63, 32]
tmp = min_feature_map_dimension / 32.
if tmp >= 2:
while tmp >= 2.:
for _ in range(2):
x = Convolution2D(nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
nb_filter *= 2
tmp /= 2
# 32x32
# Color transformation
x = Convolution2D(10, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = Activation('elu')(x)
x = Convolution2D(3, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = Activation('elu')(x)
# Normal network
x = Convolution2D(nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Convolution2D(nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Convolution2D(nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
# 16x16
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Convolution2D(2 * nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Convolution2D(2 * nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
# 8x8
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Convolution2D(2 * nb_filter, (3, 3), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
# 4x4
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Convolution2D(505, (4, 4),
padding='valid',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Dropout(0.5)(x)
# 1x1
x = Convolution2D(512, (1, 1), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = BatchNormalization()(x)
x = Activation('elu')(x)
x = Dropout(0.5)(x)
x = Convolution2D(nb_classes, (1, 1), padding='same',
kernel_initializer='he_uniform',
kernel_regularizer=l2(0.0001))(x)
x = GlobalAveragePooling2D()(x) # Adjust for FCN
x = BatchNormalization()(x)
x = Activation('softmax')(x)
model = Model(inputs=input_, outputs=x)
return model
squeeze.add(ELU(alpha=1.0))
squeeze_left = squeeze
squeeze_left.add(
Convolution2D(2, 3, 3, border_mode='valid', input_shape=input_shape))
squeeze_left.add(ELU(alpha=1.0))
squeeze_right = squeeze
squeeze_right.add(
Convolution2D(2, 3, 3, border_mode='valid', input_shape=input_shape))
squeeze_right.add(ELU(alpha=1.0))
squeeze0 = Sequential()
squeeze0.add(Merge([squeeze_left, squeeze_right], mode='concat'))
squeeze0.add(Dropout(0.2))
squeeze0.add(GlobalAveragePooling2D((1, 28, 28, 1)))
squeeze0.add(Dense(1))
squeeze0.add(Activation('sigmoid'))
squeeze0.compile(loss='mean_squared_error',
optimizer=sgd,
metrics=['accuracy'])
squeeze0.summary()
squeeze0.fit(x_train_CNN,
np.array(y_train2),
nb_epoch=15,
batch_size=30,
verbose=1)
a1 = squeeze0.predict_classes(x_train_CNN, verbose=1)
a1
def __create_nas_cell_net(nb_classes, img_input, include_top, init_filters=DEFAULT_INIT_FILTERS,
num_reduction_cells=DEFAULT_NUM_REDUCTION, repeat_val=DEFAULT_NUM_REPEAT_VALUE,
use_droppath=USE_DROPPATH, dropout_rate=DEFAULT_DROPOUT_RATE,
weight_decay=DEFAULT_WEIGHT_DECAY, activation='softmax'):
''' Build the NAS Cell model
Args:
nb_classes: number of classes
img_input: tuple of shape (channels, rows, columns) or (rows, columns, channels)
include_top: flag to include the final Dense layer
init_filters: initial number of filters. Default -1 indicates initial number of filters is 128.
num_reduction_cells: number of 2x2 strided reductions cells
repeat_val: number of normal NAS convolutional cells surrounding the reduction cells
dropout_rate: dropout rate
weight_decay: weight decay
activation: Type of activation at the top layer. Can be one of 'softmax' or 'sigmoid'.
Note that if sigmoid is used, classes must be 1.
Returns: keras tensor with nb_layers of conv_block appended
'''
# Get channel axis
concat_axis = 1 if K.image_data_format() == 'channels_first' else -1
# Create drop table
total_elements_per_NAS_cell = COMBINATIONS_PER_LAYER * ELEMENTS_PER_COMBINATION
total_cells = num_reduction_cells + ((num_reduction_cells + 1) * repeat_val)
total_elements = total_cells * total_elements_per_NAS_cell
if use_droppath:
drop_table = []
for _ in range(total_elements):
death_rate = K.variable(DEFAULT_DEATH_RATE)
gate = K.variable(1, dtype='uint16')
drop_table.append({"death_rate": death_rate, "gate": gate})
else:
drop_table = [None] * total_elements
# Begin the process of Normal NAS Cell and Reduction NAS cell sequences
dt_start = 0
dt_end = total_elements_per_NAS_cell
cur_hid = (img_input, True)
prev_hid = (img_input, True)
num_channels = init_filters
for i in range(num_reduction_cells + 1):
# Iterate N times through normal cell
for _ in range(repeat_val):
cur_spatial, cur_channels = layer_into_spatial_and_channels(cur_hid[0])
prev_hid = make_prev_match_cur_layer(prev_hid, cur_spatial, cur_channels)
tmp_prev_hid = cur_hid
cur_hid = __normal_nas_cell(prev_hid, cur_hid, num_channels,
drop_table[dt_start:dt_end], weight_decay)
prev_hid = tmp_prev_hid
dt_start += total_elements_per_NAS_cell
dt_end += total_elements_per_NAS_cell
# Double number of channels and pass through reduction cell
num_channels = int(num_channels * 2.5)
if i < num_reduction_cells:
cur_spatial, cur_channels = layer_into_spatial_and_channels(cur_hid[0])
prev_hid = make_prev_match_cur_layer(prev_hid, cur_spatial, cur_channels)
tmp_prev_hid = cur_hid
cur_hid = __reduction_nas_cell(prev_hid, cur_hid, num_channels,
drop_table[dt_start:dt_end], weight_decay)
prev_hid = tmp_prev_hid
dt_start += total_elements_per_NAS_cell
dt_end += total_elements_per_NAS_cell
# Average pool, apply dropout (if desired), and apply final FC layer
x = cur_hid[0]
x = Activation('relu')(x)
x = GlobalAveragePooling2D(name="final_embeddings")(x)
x = BatchNormalization(axis=concat_axis, gamma_regularizer=l2(weight_decay),
beta_regularizer=l2(weight_decay))(x)
if include_top:
if dropout_rate:
x = Dropout(dropout_rate, name="final_dropout")(x)
x = Dense(nb_classes, activation=activation, kernel_regularizer=l2(weight_decay),
bias_regularizer=l2(weight_decay))(x)
# Return classification logits and drop table
return x, drop_table
def ResNet(input_shape=None,
classes=10,
block='bottleneck',
residual_unit='v2',
repetitions=None,
initial_filters=64,
activation='softmax',
include_top=True,
input_tensor=None,
dropout=None,
transition_dilation_rate=(1, 1),
initial_strides=(2, 2),
initial_kernel_size=(7, 7),
initial_pooling='max',
final_pooling=None,
top='classification'):
"""Builds a custom ResNet like architecture. Defaults to ResNet50 v2.
Args:
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` dim ordering)
or `(3, 224, 224)` (with `channels_first` dim ordering).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 8.
E.g. `(224, 224, 3)` would be one valid value.
classes: The number of outputs at final softmax layer
block: The block function to use. This is either `'basic'` or `'bottleneck'`.
The original paper used `basic` for layers < 50.
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size is halved.
Default of None implies the ResNet50v2 values of [3, 4, 6, 3].
transition_dilation_rate: Used for pixel-wise prediction tasks such as image segmentation.
residual_unit: the basic residual unit, 'v1' for conv bn relu, 'v2' for bn relu conv.
See [Identity Mappings in Deep Residual Networks](https://arxiv.org/abs/1603.05027)
for details.
dropout: None for no dropout, otherwise rate of dropout from 0 to 1.
Based on [Wide Residual Networks.(https://arxiv.org/pdf/1605.07146) paper.
transition_dilation_rate: Dilation rate for transition layers. For semantic
segmentation of images use a dilation rate of (2, 2).
initial_strides: Stride of the very first residual unit and MaxPooling2D call,
with default (2, 2), set to (1, 1) for small images like cifar.
initial_kernel_size: kernel size of the very first convolution, (7, 7) for imagenet
and (3, 3) for small image datasets like tiny imagenet and cifar.
See [ResNeXt](https://arxiv.org/abs/1611.05431) paper for details.
initial_pooling: Determine if there will be an initial pooling layer,
'max' for imagenet and None for small image datasets.
See [ResNeXt](https://arxiv.org/abs/1611.05431) paper for details.
final_pooling: Optional pooling mode for feature extraction at the final model layer
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.
top: Defines final layers to evaluate based on a specific problem type. Options are
'classification' for ImageNet style problems, 'segmentation' for problems like
the Pascal VOC dataset, and None to exclude these layers entirely.
Returns:
The keras `Model`.
"""
if activation not in ['softmax', 'sigmoid', None]:
raise ValueError(
'activation must be one of "softmax", "sigmoid", or None')
if activation == 'sigmoid' and classes != 1:
raise ValueError(
'sigmoid activation can only be used when classes = 1')
if repetitions is None:
repetitions = [3, 4, 6, 3]
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=32,
min_size=8,
data_format=K.image_data_format(),
require_flatten=include_top)
_handle_dim_ordering()
if len(input_shape) != 3:
raise Exception(
"Input shape should be a tuple (nb_channels, nb_rows, nb_cols)")
if block == 'basic':
block_fn = basic_block
elif block == 'bottleneck':
block_fn = bottleneck
elif isinstance(block, six.string_types):
block_fn = _string_to_function(block)
else:
block_fn = block
if residual_unit == 'v2':
residual_unit = _bn_relu_conv
elif residual_unit == 'v1':
residual_unit = _conv_bn_relu
elif isinstance(residual_unit, six.string_types):
residual_unit = _string_to_function(residual_unit)
else:
residual_unit = residual_unit
# Permute dimension order if necessary
if K.image_data_format() == 'channels_first':
input_shape = (input_shape[1], input_shape[2], input_shape[0])
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=32,
min_size=8,
data_format=K.image_data_format(),
require_flatten=include_top)
img_input = Input(shape=input_shape, tensor=input_tensor)
x = _conv_bn_relu(filters=initial_filters,
kernel_size=initial_kernel_size,
strides=initial_strides)(img_input)
if initial_pooling == 'max':
x = MaxPooling2D(pool_size=(3, 3),
strides=initial_strides,
padding="same")(x)
block = x
filters = initial_filters
for i, r in enumerate(repetitions):
transition_dilation_rates = [transition_dilation_rate] * r
transition_strides = [(1, 1)] * r
if transition_dilation_rate == (1, 1):
transition_strides[0] = (2, 2)
block = _residual_block(
block_fn,
filters=filters,
stage=i,
blocks=r,
is_first_layer=(i == 0),
dropout=dropout,
transition_dilation_rates=transition_dilation_rates,
transition_strides=transition_strides,
residual_unit=residual_unit)(block)
filters *= 2
# Last activation
x = _bn_relu(block)
# Classifier block
if include_top and top is 'classification':
x = GlobalAveragePooling2D()(x)
x = Dense(units=classes,
activation=activation,
kernel_initializer="he_normal")(x)
elif include_top and top is 'segmentation':
x = Conv2D(classes, (1, 1), activation='linear', padding='same')(x)
if K.image_data_format() == 'channels_first':
channel, row, col = input_shape
else:
row, col, channel = input_shape
x = Reshape((row * col, classes))(x)
x = Activation(activation)(x)
x = Reshape((row, col, classes))(x)
elif final_pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif final_pooling == 'max':
x = GlobalMaxPooling2D()(x)
model = Model(inputs=img_input, outputs=x)
return model
from keras.datasets import cifar10
from keras.utils import np_utils
from keras.layers.normalization import BatchNormalization
input_1 = Input(shape=(32, 32, 3), name="head")
x1 = Conv2D(16, (3, 3), padding='same', name='2-1')(input_1)
x2 = Conv2D(16, (3, 3), padding='same', name='2-2')(input_1)
x3 = Conv2D(16, (3, 3), padding='same', name='2-3')(input_1)
x4 = Conv2D(10, (3, 3), padding='same', name='3-1')(x1)
x5 = Concatenate(axis=3, name="3-2")([x1, x2])
x6 = Concatenate(axis=3, name="3-3")([x2, x3])
x7 = Conv2D(10, (3, 3), padding='same', name='3-4')(x3)
out1 = GlobalAveragePooling2D(name="4-1")(x4)
out1 = Activation('softmax', name='r_hand')(out1)
x10 = Concatenate(axis=3, name="4-2")([x5, x6])
out4 = GlobalAveragePooling2D(name="4-3")(x7)
out4 = Activation('softmax', name='l_hand')(out4)
x11 = MaxPooling2D(pool_size=(2, 2), name="5-1")(x10)
out2 = Flatten(name="6-1")(x11)
out2 = Dense(10, activation='relu', name="7-1")(out2)
out2 = Activation('softmax', name="r_foot")(out2)
out3 = Flatten(name="6-2")(x11)
out3 = Dense(10, activation='relu', name="7-2")(out3)
def get_squeezenet(nb_classes, dim_ordering='tf'):
if dim_ordering is 'th':
input_img = Input(shape=(3, 227, 227))
elif dim_ordering is 'tf':
input_img = Input(shape=(227, 227, 3))
else:
raise NotImplementedError("Theano and Tensorflow are only available")
x = Convolution2D(64,
3,
3,
subsample=(2, 2),
border_mode='valid',
name='conv1')(input_img)
x = Activation('relu', name='relu_conv1')(x)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool1')(x)
x = fire_module(x,
fire_id=2,
squeeze=16,
expand=64,
dim_ordering=dim_ordering)
x = fire_module(x,
fire_id=3,
squeeze=16,
expand=64,
dim_ordering=dim_ordering)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool3')(x)
x = fire_module(x,
fire_id=4,
squeeze=32,
expand=128,
dim_ordering=dim_ordering)
x = fire_module(x,
fire_id=5,
squeeze=32,
expand=128,
dim_ordering=dim_ordering)
x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x)
x = fire_module(x,
fire_id=6,
squeeze=48,
expand=192,
dim_ordering=dim_ordering)
x = fire_module(x,
fire_id=7,
squeeze=48,
expand=192,
dim_ordering=dim_ordering)
x = fire_module(x,
fire_id=8,
squeeze=64,
expand=256,
dim_ordering=dim_ordering)
x = fire_module(x,
fire_id=9,
squeeze=64,
expand=256,
dim_ordering=dim_ordering)
x = Dropout(0.5, name='drop9')(x)
x = Convolution2D(nb_classes, 1, 1, border_mode='valid', name='conv10')(x)
x = Activation('relu', name='relu_conv10')(x)
x = GlobalAveragePooling2D()(x)
out = Activation('softmax', name='loss')(x)
model = Model(input=input_img, output=[out])
return model
def densenet121_model(img_rows,
img_cols,
color_type=1,
nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.5,
dropout_rate=0.0,
weight_decay=1e-4,
num_classes=None):
'''
DenseNet 121 Model for Keras
Model Schema is based on
https://github.com/flyyufelix/DenseNet-Keras
ImageNet Pretrained Weights
Theano: https://drive.google.com/open?id=0Byy2AcGyEVxfMlRYb3YzV210VzQ
TensorFlow: https://drive.google.com/open?id=0Byy2AcGyEVxfSTA4SHJVOHNuTXc
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(img_rows, img_cols, color_type), name='data')
else:
concat_axis = 1
img_input = Input(shape=(color_type, img_rows, img_cols), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 24, 16] # For DenseNet-121
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x_fc = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_fc = Dense(1000, name='fc6')(x_fc)
x_fc = Activation('softmax', name='prob')(x_fc)
model = Model(img_input, x_fc, name='densenet')
if K.image_dim_ordering() == 'th':
# Use pre-trained weights for Theano backend
weights_path = 'imagenet_models/densenet121_weights_th.h5'
else:
# Use pre-trained weights for Tensorflow backend
weights_path = 'imagenet_models/densenet121_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 = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x_newfc = Dense(num_classes, name='fc6')(x_newfc)
x_newfc = Activation('softmax', name='prob')(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
def cnn_model(model_name, img_size):
"""
Model definition using Xception net architecture
"""
input_size = (img_size, img_size, 3)
if model_name == "xception":
print("Loading Xception wts...")
baseModel = Xception(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "iv3":
baseModel = InceptionV3(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "irv2":
baseModel = InceptionResNetV2(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "resnet":
baseModel = ResNet50(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "nasnet":
baseModel = NASNetLarge(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "ef0":
baseModel = EfficientNetB0(input_size,
weights="imagenet",
include_top=False)
elif model_name == "ef5":
baseModel = EfficientNetB5(input_size,
weights="imagenet",
include_top=False)
headModel = baseModel.output
headModel = GlobalAveragePooling2D()(headModel)
headModel = Dense(512, activation="relu",
kernel_initializer="he_uniform")(headModel)
headModel = Dropout(0.4)(headModel)
# headModel = Dense(512, activation="relu", kernel_initializer="he_uniform")(
# headModel
# )
# headModel = Dropout(0.5)(headModel)
predictions = Dense(5,
activation="softmax",
kernel_initializer="he_uniform")(headModel)
model = Model(inputs=baseModel.input, outputs=predictions)
for layer in baseModel.layers:
layer.trainable = False
optimizer = Nadam(lr=0.002,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
schedule_decay=0.004)
model.compile(loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"])
return model
def __create_res_next_imagenet(nb_classes,
img_input,
include_top,
depth,
cardinality=32,
width=4,
weight_decay=5e-4,
pooling=None,
attention_module=None,
activation='softmax'):
''' Creates a ResNeXt model with specified parameters
Args:
nb_classes: Number of output classes
img_input: Input tensor or layer
include_top: Flag to include the last dense layer
depth: Depth of the network. List of integers.
Increasing cardinality improves classification accuracy,
width: Width of the network.
weight_decay: weight_decay (l2 norm)
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.
Returns: a Keras Model
'''
if type(depth) is list or type(depth) is tuple:
# If a list is provided, defer to user how many blocks are present
N = list(depth)
else:
# Otherwise, default to 3 blocks each of default number of group convolution blocks
N = [(depth - 2) // 9 for _ in range(3)]
filters = cardinality * width
filters_list = []
for i in range(len(N)):
filters_list.append(filters)
filters *= 2 # double the size of the filters
x = __initial_conv_block_inception(img_input, weight_decay)
# block 1 (no pooling)
for i in range(N[0]):
x = __bottleneck_block(x,
filters_list[0],
cardinality,
strides=1,
weight_decay=weight_decay,
attention_module=attention_module)
N = N[1:] # remove the first block from block definition list
filters_list = filters_list[
1:] # remove the first filter from the filter list
# block 2 to N
for block_idx, n_i in enumerate(N):
for i in range(n_i):
if i == 0:
x = __bottleneck_block(x,
filters_list[block_idx],
cardinality,
strides=2,
weight_decay=weight_decay,
attention_module=attention_module)
else:
x = __bottleneck_block(x,
filters_list[block_idx],
cardinality,
strides=1,
weight_decay=weight_decay,
attention_module=attention_module)
if include_top:
x = GlobalAveragePooling2D()(x)
x = Dense(nb_classes,
use_bias=False,
kernel_regularizer=l2(weight_decay),
kernel_initializer='he_normal',
activation=activation)(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
return x
def discriminator(img_dim, bn_mode, model_name="discriminator"):
"""DCGAN discriminator
Args:
img_dim: dimension of the image output
bn_mode: keras batchnorm mode
model_name: model name (default: {"generator_deconv"})
Returns:
keras model
"""
if K.image_dim_ordering() == "th":
bn_axis = 1
min_s = min(img_dim[1:])
else:
bn_axis = -1
min_s = min(img_dim[:-1])
disc_input = Input(shape=img_dim, name="discriminator_input")
# Get the list of number of conv filters
# (first layer starts with 64), filters are subsequently doubled
nb_conv = int(np.floor(np.log(min_s // 4) / np.log(2)))
list_f = [64 * min(8, (2**i)) for i in range(nb_conv)]
# First conv with 2x2 strides
x = Conv2D(list_f[0], (3, 3),
strides=(2, 2),
name="disc_conv2d_1",
padding="same",
use_bias=False,
kernel_initializer=RandomNormal(stddev=0.02))(disc_input)
x = BatchNormalization(axis=bn_axis)(x)
x = LeakyReLU(0.2)(x)
# Conv blocks: Conv2D(2x2 strides)->BN->LReLU
for i, f in enumerate(list_f[1:]):
name = "disc_conv2d_%s" % (i + 2)
x = Conv2D(f, (3, 3),
strides=(2, 2),
name=name,
padding="same",
use_bias=False,
kernel_initializer=RandomNormal(stddev=0.02))(x)
x = BatchNormalization(axis=bn_axis)(x)
x = LeakyReLU(0.2)(x)
# Last convolution
x = Conv2D(1, (3, 3),
name="last_conv",
padding="same",
use_bias=False,
kernel_initializer=RandomNormal(stddev=0.02))(x)
# Average pooling
x = GlobalAveragePooling2D()(x)
discriminator_model = Model(inputs=[disc_input],
outputs=[x],
name=model_name)
visualize_model(discriminator_model)
return discriminator_model
def __create_dense_net(nb_classes, img_input, include_top, depth=40, nb_dense_block=3, growth_rate=12, nb_filter=-1,
nb_layers_per_block=-1, bottleneck=False, reduction=0.0, dropout_rate=None, weight_decay=1e-4,
subsample_initial_block=False, activation='softmax'):
''' Build the DenseNet model
Args:
nb_classes: number of classes
img_input: tuple of shape (channels, rows, columns) or (rows, columns, channels)
include_top: flag to include the final Dense layer
depth: number or layers
nb_dense_block: number of dense blocks to add to end (generally = 3)
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters. Default -1 indicates initial number of filters is 2 * growth_rate
nb_layers_per_block: number of layers in each dense block.
Can be a -1, positive integer or a list.
If -1, calculates nb_layer_per_block from the depth of the network.
If positive integer, a set number of layers per dense block.
If list, nb_layer is used as provided. Note that list size must
be (nb_dense_block + 1)
bottleneck: add bottleneck blocks
reduction: reduction factor of transition blocks. Note : reduction value is inverted to compute compression
dropout_rate: dropout rate
weight_decay: weight decay rate
subsample_initial_block: Set to True to subsample the initial convolution and
add a MaxPool2D before the dense blocks are added.
subsample_initial:
activation: Type of activation at the top layer. Can be one of 'softmax' or 'sigmoid'.
Note that if sigmoid is used, classes must be 1.
Returns: keras tensor with nb_layers of conv_block appended
'''
concat_axis = 1 if K.image_data_format() == 'channels_first' else -1
if reduction != 0.0:
assert reduction <= 1.0 and reduction > 0.0, 'reduction value must lie between 0.0 and 1.0'
# layers in each dense block
if type(nb_layers_per_block) is list or type(nb_layers_per_block) is tuple:
nb_layers = list(nb_layers_per_block) # Convert tuple to list
assert len(nb_layers) == (nb_dense_block), 'If list, nb_layer is used as provided. ' \
'Note that list size must be (nb_dense_block)'
final_nb_layer = nb_layers[-1]
nb_layers = nb_layers[:-1]
else:
if nb_layers_per_block == -1:
assert (depth - 4) % 3 == 0, 'Depth must be 3 N + 4 if nb_layers_per_block == -1'
count = int((depth - 4) / 3)
nb_layers = [count for _ in range(nb_dense_block)]
final_nb_layer = count
else:
final_nb_layer = nb_layers_per_block
nb_layers = [nb_layers_per_block] * nb_dense_block
# compute initial nb_filter if -1, else accept users initial nb_filter
if nb_filter <= 0:
nb_filter = 2 * growth_rate
# compute compression factor
compression = 1.0 - reduction
# Initial convolution
if subsample_initial_block:
initial_kernel = (7, 7)
initial_strides = (2, 2)
else:
initial_kernel = (3, 3)
initial_strides = (1, 1)
x = Conv2D(nb_filter, initial_kernel, kernel_initializer='he_normal', padding='same',
strides=initial_strides, use_bias=False, kernel_regularizer=l2(weight_decay))(img_input)
if subsample_initial_block:
x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(x)
x = Activation('relu')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
x, nb_filter = __dense_block(x, nb_layers[block_idx], nb_filter, growth_rate, bottleneck=bottleneck,
dropout_rate=dropout_rate, weight_decay=weight_decay)
# add transition_block
x = __transition_block(x, nb_filter, compression=compression, weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
# The last dense_block does not have a transition_block
x, nb_filter = __dense_block(x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck,
dropout_rate=dropout_rate, weight_decay=weight_decay)
x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5)(x)
x = Activation('relu')(x)
x = GlobalAveragePooling2D()(x)
if include_top:
x = Dense(nb_classes, activation=activation)(x)
return x
def DenseNet(nb_classes,
img_dim,
depth,
nb_dense_block,
growth_rate,
nb_filter,
dropout_rate=None,
weight_decay=1E-4):
""" Build the DenseNet model
:param nb_classes: int -- number of classes
:param img_dim: tuple -- (channels, rows, columns)
:param depth: int -- how many layers
:param nb_dense_block: int -- number of dense blocks to add to end
:param growth_rate: int -- number of filters to add
:param nb_filter: int -- number of filters
:param dropout_rate: float -- dropout rate
:param weight_decay: float -- weight decay
:returns: keras model with nb_layers of conv_factory appended
:rtype: keras model
"""
model_input = Input(shape=img_dim)
assert (depth - 4) % 3 == 0, "Depth must be 3 N + 4"
# layers in each dense block
nb_layers = int((depth - 4) / 3)
# Initial convolution
x = Convolution2D(nb_filter,
3,
3,
init="he_uniform",
border_mode="same",
name="initial_conv2D",
bias=False,
W_regularizer=l2(weight_decay))(model_input)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
x, nb_filter = denseblock(x,
nb_layers,
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# add transition
x = transition(x,
nb_filter,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# The last denseblock does not have a transition
x, nb_filter = denseblock(x,
nb_layers,
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(mode=0,
axis=1,
gamma_regularizer=l2(weight_decay),
beta_regularizer=l2(weight_decay))(x)
x = Activation('relu')(x)
x = GlobalAveragePooling2D(dim_ordering="th")(x)
x = Dense(nb_classes,
activation='softmax',
W_regularizer=l2(weight_decay),
b_regularizer=l2(weight_decay))(x)
densenet = Model(input=[model_input], output=[x], name="DenseNet")
# optimizer=SGD
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
densenet.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy', precision, recall, f1score])
return densenet
def X4(inputa,
inputb,
inputc,
demographics=None,
dropout=0.8,
num_cls=1000,
is_train=True,
scope='X4',
supermd=False):
with tf.variable_scope(scope, 'X4', [inputa, inputb, inputc]):
xa, auxa = Branch(inputa,
dropout_keep_prob=dropout,
num_classes=num_cls,
is_training=is_train)
xb, auxb = Branch(inputb,
dropout_keep_prob=dropout,
num_classes=num_cls,
is_training=is_train)
xc, auxc = Branch(inputc,
dropout_keep_prob=dropout,
num_classes=num_cls,
is_training=is_train)
x = concatenate([xa, xb, xc], axis=3) # Output: 8 * 8 * 2688
x = Conv2D(2688, (1, 1),
kernel_regularizer=l2(0.0002),
activation="relu",
padding="same")(x)
net = x
loss2_classifier = tf.add(auxa, tf.add(auxb, auxc))
# Average Pooling
x = GlobalAveragePooling2D(name='avg_pool')(x) # Output: 2688
pool5_drop_10x10_s1 = Dropout(dropout)(x, training=is_train)
if supermd:
demographics = Dense(2,
name='demographic_fc1',
activation="relu",
kernel_regularizer=l2(0.0002))(demographics)
merged = concatenate([pool5_drop_10x10_s1, demographics])
else:
merged = pool5_drop_10x10_s1
loss3_classifier_w = Dense(num_cls,
name='loss3/classifier',
kernel_regularizer=l2(0.0002))
loss3_classifier = loss3_classifier_w(merged)
w_variables = loss3_classifier_w.get_weights()
w_variables = w_variables[0]
logits = tf.cond(
tf.equal(is_train, tf.constant(True)),
lambda: tf.add(loss3_classifier,
tf.scalar_mul(tf.constant(0.1), loss2_classifier)),
lambda: loss3_classifier)
return logits, net, tf.convert_to_tensor(w_variables)
def fit(image_dir: str = IMAGE_DIR, dump: bool = True, **kwargs):
""" Read and resize images
Save all the data in:
TRAIN_X - pixels
TRAIN_Y - labels
"""
logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = TensorBoard(log_dir=logdir)
model_checkpoint = ModelCheckpoint(
str(MODELS_DIR /
'weights-improvement-{epoch:02d}-{val_accuracy:.2f}.hdf5'),
monitor='val_loss',
verbose=0,
save_best_only=False,
save_weights_only=False,
mode='auto',
period=1)
reduce_lron = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=3,
verbose=1,
mode='auto')
base_model = InceptionV3(include_top=False,
weights='imagenet',
input_shape=(WIDHT, HEIGHT, 3))
for layer in base_model.layers:
layer.trainable = False
model = Sequential()
model.add(base_model)
model.add(GlobalAveragePooling2D())
model.add(Dense(1024, activation='relu', kernel_regularizer=l2(0.0001)))
model.add(Dense(LABEL_SIZE, activation='softmax'))
model.compile(
loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'],
)
train_generator = augs_gen.flow_from_directory(
directory=IMAGE_DIR,
target_size=WH,
batch_size=BATCH_SIZE,
seed=1,
shuffle=True,
subset='training',
)
test_generator = augs_gen.flow_from_directory(
directory=IMAGE_DIR,
target_size=WH,
batch_size=BATCH_SIZE,
seed=1,
shuffle=True,
subset='validation',
)
labels = (train_generator.class_indices)
labels = dict((v, k) for k, v in labels.items())
with open(DATA_DIR / 'generator_labels.dump', 'wb') as file:
pickle.dump(labels, file)
with graph.as_default():
model.fit_generator(
train_generator,
validation_data=test_generator,
steps_per_epoch=train_generator.samples // BATCH_SIZE,
validation_steps=test_generator.samples // BATCH_SIZE,
epochs=EPOCHS,
verbose=1,
callbacks=[tensorboard_callback, model_checkpoint, reduce_lron],
)
print('Prepare to write data on the disk')
model.save(f'{model_name}.dump')
