def buildModel(shape, dr1=0.1, dr2=0.5):
""" Build a keras model to be trained. This uses the architecture discussed in the lecture
that is said to be published by the NVidia Autonomous Vehicle Team.
'shape' is the input shape, assumed to be 3 dimensional.
'dr1' is the drop out rate for the convolutional layers.
'dr2' is the drop out rate for the fully connected layers.
"""
assert len(shape) == 3
# We import keras here to avoid importing it (and a ton of other stuff) when running
# the 'show_gui.py' script (which imports this script).
import keras.models as _kmod
import keras.layers as _klay
model = _kmod.Sequential()
# First crop and normalize the image(s).
# Note that this is part of the model, and not part of loading the data, since it
# needs to be done when the model is invoked by the simulator (in drive.py), and I didn't
# want to modify drive.py and try to keep it in sync with this.
# Ignore the top 42% and the bottom 15%.
cropTop = int(shape[0] * 0.42)
cropBot = int(shape[0] * 0.15)
model.add(
_klay.Cropping2D(cropping=((cropTop, cropBot), (0, 0)),
input_shape=shape))
# Use very basic image normalization to get values between -0.5 and 0.5.
model.add(_klay.Lambda(lambda x: x / 255.0 - 0.5))
# Do three 5x5 convolutions with stride 2.
model.add(
_klay.Convolution2D(24, 5, 5, subsample=(2, 2), activation='relu'))
model.add(_klay.SpatialDropout2D(dr1))
model.add(
_klay.Convolution2D(36, 5, 5, subsample=(2, 2), activation='relu'))
model.add(_klay.SpatialDropout2D(dr1))
model.add(
_klay.Convolution2D(48, 5, 5, subsample=(2, 2), activation='relu'))
# Do two 3x3 convolutions with stride 1
model.add(_klay.SpatialDropout2D(dr1))
model.add(
_klay.Convolution2D(64, 3, 3, subsample=(1, 1), activation='relu'))
model.add(_klay.SpatialDropout2D(dr1))
model.add(
_klay.Convolution2D(64, 3, 3, subsample=(1, 1), activation='relu'))
# Do three fully connected layers.
model.add(_klay.Flatten())
model.add(_klay.Dropout(dr2))
model.add(_klay.Dense(100, activation='relu'))
model.add(_klay.Dropout(dr2))
model.add(_klay.Dense(50, activation='relu'))
model.add(_klay.Dropout(dr2))
model.add(_klay.Dense(1))
return model
def run_cnn_1(conv1, conv2, conv3, train, test, img_shape, lr=0.001, fc1=5,
do=0.5, n_classes=None, model=None):
model_input = layers.Input(shape=img_shape, name="Input")
x = layers.Conv2D(2**(conv1), kernel_size=(3, 3), activation="relu",
padding="same", name="Conv1")(model_input)
x = layers.MaxPooling2D(pool_size=(2, 2), name="Pool1")(x)
x = layers.SpatialDropout2D(rate=do, name='Dropout2D_1')(x)
x = layers.Conv2D(2**(conv2), kernel_size=(3, 3), activation="relu",
padding="same", name="Conv2")(x)
x = layers.MaxPooling2D(pool_size=(2, 2), name="Pool2")(x)
x = layers.SpatialDropout2D(rate=do, name='Dropout2D_2')(x)
x = layers.Conv2D(2**(conv3), kernel_size=(3, 3), activation="relu",
padding="same", name="Conv4")(x)
x = layers.MaxPooling2D(pool_size=(2, 2), name="Pool3")(x)
x = layers.SpatialDropout2D(rate=do, name='Dropout2D_3')(x)
x = layers.Flatten(name="Flatten")(x)
x = layers.Dense(2**(fc1), activation="relu", name="FC1")(x)
x = layers.Dense(2**(fc1-1), activation="relu", name="FC2")(x)
x = layers.Dropout(rate=do,name='Dropout')(x)
model_output = layers.Dense(n_classes, activation='sigmoid',
name="Output")(x)
model = models.Model(model_input, model_output)
# Inicializa o otimizador. Adam é uma variação do SGD
optimizer = optimizers.Adam(lr=lr)
# Compila o modelo, escolhendo a funcao de perda e a metrica principal
model.compile(optimizer, loss="binary_crossentropy", metrics=["accuracy"])
model.summary()
# Treina por 10 epocas com mini-batches de 32 exemplos.
# A API aceita tambem dados de validacao, que sao usadas ao final
# de cada epoca para medir a metrica principal
history = model.fit(train[0], train[1], batch_size=8,
epochs=20, validation_data=test)
return history, model
def _get_deeplab_v3(self, use_cbam=False, use_se=False):
img_height, img_width = self.input_shape[0], self.input_shape[1]
backbone_model = self._get_backbone_model()
feature_layers = _FEATURE_LAYERS[self.backbone_name]
img_features = backbone_model.get_layer(feature_layers[2]).output
if use_cbam:
img_features = cbam(img_features)
if self.cfn_model is not None:
img_features = self._concatenate_cfn_features(img_features, backbone_model)
x = aspp(img_features)
h_t, w_t, c_t = K.int_shape(x)[1:]
scale = int((img_height / 4) // h_t), int((img_width / 4) // w_t)
x = self._upsample_features(x, scale, c_t)
y = conv(backbone_model.get_layer(feature_layers[0]).output, 64, 1)
if use_cbam:
y = cbam(y)
if use_se:
y = se_block(y)
x = layers.concatenate([x, y])
x = conv(x, num_filters=128, kernel_size=3)
x = layers.SpatialDropout2D(self.dropout_rate)(x)
x = conv(x, num_filters=128, kernel_size=3)
if use_cbam:
x = cbam(x)
if use_se:
x = se_block(x)
h_t, w_t, c_t = K.int_shape(x)[1:]
scale = img_height // h_t, img_width // w_t
x = self._upsample_features(x, scale, c_t)
x = layers.Conv2D(self.n_classes, (1, 1))(x)
o = layers.Activation('sigmoid', name='output_layer')(x)
return models.Model(inputs=backbone_model.input, outputs=o)
def conv_bn_block(inputs, filters, k_size, stride, padding, name):
out = layers.Conv2D(filters=filters,
kernel_size=k_size,
strides=stride,
padding=padding,
name=name)(inputs)
out = layers.BatchNormalization()(out)
out = layers.ReLU()(out)
return layers.SpatialDropout2D(rate=0.3)(out)
def keras_dropout(layer, rate):
input_dim = len(layer.input.shape)
if input_dim == 2:
return layers.SpatialDropout1D(rate)
elif input_dim == 3:
return layers.SpatialDropout2D(rate)
elif input_dim == 4:
return layers.SpatialDropout3D(rate)
else:
return layers.Dropout(rate)
def __init__(self, filters_size, dropout_rate):
self._convolution_transpose = layers.Conv2DTranspose(
filters_size,
kernel_size=(3, 3),
padding='same',
strides=(2, 2),
kernel_initializer='he_normal',
kernel_regularizer=regularizers.l2(1e-4))
self._concatenation = layers.Concatenate(axis=-1)
self._convo_block = ConvoBlock(filters_size)
self._dropout = layers.SpatialDropout2D(rate=dropout_rate)
def capsule_model(inputs, args):
out = conv_bn_block(inputs,
filters=64,
k_size=7,
stride=2,
padding="same",
name="conv_block_1")
# out = inception_block(out, nb_channels=64, name="inception0")
# out = layers.SpatialDropout2D(rate=0.3)(out)
# out = inception_block(out, nb_channels=128, name="inception1")
# out = layers.SpatialDropout2D(rate=0.3)(out)
if args.model_type == "rc":
out = residual_block(out, nb_channels=128, _project_shortcut=True)
out = layers.SpatialDropout2D(rate=0.3)(out)
out = residual_block(out, nb_channels=256, _project_shortcut=True)
out = layers.SpatialDropout2D(rate=0.3)(out)
else:
out = conv_bn_block(out,
filters=128,
k_size=7,
stride=2,
padding="same",
name="conv_block_2")
out = conv_bn_block(out,
filters=64,
k_size=7,
stride=2,
padding="same",
name="conv_block_3")
out = primary_capsule(out, dim_capsule=16, name="primarycaps", args=args)
out = FashionCaps(num_capsule=args.num_class,
dim_capsule=args.dim_capsule,
routings=3,
name="fashioncaps")(out)
return out
def get_keras_model(self, verbose=False):
model = Sequential()
model.add(layers.InputLayer(input_shape=self.input_shape))
conv_counter = 0
for conv_layer in self.conv_layers:
conv_counter += 1
kernel_initializer = conv_layer[
"kernel_initializer"] if "kernel_initializer" in conv_layer else "glorot_uniform"
model.add(
layers.Conv2D(conv_layer["filters"],
conv_layer["kernel_size"],
strides=conv_layer["strides"],
padding=conv_layer["padding"],
activation=conv_layer["activation"],
kernel_initializer=kernel_initializer,
name=conv_layer_name(conv_counter),
data_format=self.data_format))
model.add(
layers.MaxPool2D(pool_size=conv_layer["max_pooling"]["size"],
strides=conv_layer["max_pooling"].get(
"strides", None),
data_format=self.data_format))
if "dropout" in conv_layer:
model.add(
layers.SpatialDropout2D(conv_layer["dropout"],
data_format='channels_first'))
model.add(layers.Flatten(data_format='channels_first'))
dense_counter = 0
for dense_layer in self.dense_layers:
dense_counter += 1
kernel_initializer = dense_layer[
"kernel_initializer"] if "kernel_initializer" in dense_layer else "glorot_uniform"
model.add(
layers.Dense(dense_layer["units"],
activation=dense_layer["activation"],
kernel_initializer=kernel_initializer,
name=dense_layer_name(dense_counter)))
if "dropout" in dense_layer:
model.add(layers.Dropout(dense_layer["dropout"]))
if verbose:
model.summary()
return model
def cbam_attn_unet(n_ch, patch_height, patch_width):
K.set_image_data_format('channels_first')
inputs = layers.Input(shape=(n_ch, patch_height, patch_width))
conv1 = conv2d_block(inputs, n_filters=32, kernel_size=3, batchnorm=True)
conv1 = layers.SpatialDropout2D(0.1)(conv1)
conv1 = cbam_block(conv1)
pool1 = layers.MaxPooling2D((2, 2))(conv1)
#
conv2 = conv2d_block(pool1, n_filters=64, kernel_size=3, batchnorm=True)
conv2 = layers.SpatialDropout2D(0.1)(conv2)
conv2 = cbam_block(conv2)
pool2 = layers.MaxPooling2D((2, 2))(conv2)
#center
conv3 = conv2d_block(pool2, n_filters=128, kernel_size=3, batchnorm=True)
conv3 = layers.SpatialDropout2D(0.4)(conv3)
conv3 = cbam_block(conv3)
up1 = layers.UpSampling2D(size=(2, 2))(conv3)
up1 = layers.concatenate([conv2, up1], axis=1)
conv4 = conv2d_block(up1, n_filters=64, kernel_size=3, batchnorm=True)
conv4 = cbam_block(conv4)
up2 = layers.UpSampling2D(size=(2, 2))(conv4)
up2 = layers.concatenate([conv1, up2], axis=1)
conv5 = conv2d_block(up2, n_filters=32, kernel_size=3, batchnorm=True)
conv5 = cbam_block(conv5)
conv6 = layers.Conv2D(2, (1, 1), activation='relu', padding='same')(conv5)
conv6 = layers.core.Reshape((2, patch_height * patch_width))(conv6)
conv6 = layers.core.Permute((2, 1))(conv6)
############
conv7 = layers.core.Activation('softmax')(conv6)
def keras_dropout(layer, rate):
'''keras dropout layer.
'''
from keras import layers
input_dim = len(layer.input.shape)
if input_dim == 2:
return layers.SpatialDropout1D(rate)
elif input_dim == 3:
return layers.SpatialDropout2D(rate)
elif input_dim == 4:
return layers.SpatialDropout3D(rate)
else:
return layers.Dropout(rate)
def get_model0(Input_img_shape=(300, 300, 3)):
def conv_bn(x, filt, dl_rate=(1, 1), preblock=False):
y = layers.Convolution2D(filt, (3, 3),
activation='linear',
padding='same',
dilation_rate=dl_rate,
use_bias=False)(x)
if preblock:
return y
y = layers.BatchNormalization()(y)
return layers.Activation('elu')(y)
#in_layer = layers.Input(t_x.shape[1:], name = 'RGB_Input')
in_layer = layers.Input(Input_img_shape, name='RGB_Input')
pp_in_layer = layers.GaussianNoise(GAUSSIAN_NOISE)(in_layer)
pp_in_layer = layers.BatchNormalization()(pp_in_layer)
c = conv_bn(pp_in_layer, BASE_DEPTH // 2)
c = conv_bn(c, BASE_DEPTH // 2)
c = conv_bn(c, BASE_DEPTH)
skip_layers = [pp_in_layer]
for j in range(BLOCK_COUNT):
depth_steps = int(np.log2(Input_img_shape[0]) - 2)
d = layers.concatenate(skip_layers + [
conv_bn(c, BASE_DEPTH * 2**j, (2**i, 2**i), preblock=True)
for i in range(depth_steps)
])
d = layers.SpatialDropout2D(SPATIAL_DROPOUT)(d)
d = layers.BatchNormalization()(d)
d = layers.Activation('elu')(d)
# bottleneck
d = conv_bn(d, BASE_DEPTH * 2**(j + 1))
skip_layers += [c]
c = d
d = layers.Convolution2D(1, (1, 1), activation='sigmoid',
padding='same')(d)
d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d)
d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d)
seg_model = models.Model(inputs=[in_layer], outputs=[d])
#seg_model.summary()
return seg_model
def _get_fpn(self):
pyramid_features = 128
seg_features = 64
backbone_model = self._get_backbone_model()
feature_layers = _FEATURE_LAYERS[self.backbone_name]
img_features = backbone_model.get_layer(feature_layers[-1]).output
cfn_features = None
if self.cfn_model is not None:
cfn_model = models.Model(inputs=self.cfn_model.input,
outputs=self.cfn_model.get_layer(feature_layers[-1]).output)
for layer in cfn_model.layers:
layer.trainable = False
cfn_features = cfn_model(backbone_model.input)
skips = [backbone_model.get_layer(n).output for n in feature_layers[:-1]]
p1 = fpn_block(img_features, cfn_features, pyramid_features, skips[-1])
p2 = fpn_block(p1, cfn_features, pyramid_features, skips[-2])
p3 = fpn_block(p2, cfn_features, pyramid_features, skips[-3])
s1 = conv(p1, seg_features, 3)
s1 = conv(s1, seg_features, 3)
s2 = conv(p2, seg_features, 3)
s2 = conv(s2, seg_features, 3)
s3 = conv(p3, seg_features, 3)
s3 = conv(s3, seg_features, 3)
s1 = layers.UpSampling2D(4, interpolation='bilinear')(s1)
s2 = layers.UpSampling2D(2, interpolation='bilinear')(s2)
x = layers.concatenate([s1, s2, s3])
x = layers.SpatialDropout2D(self.dropout_rate)(x)
x = conv(x, seg_features, 3)
x = layers.UpSampling2D(4, interpolation='bilinear')(x)
x = layers.Conv2D(self.n_classes, (1, 1))(x)
o = layers.Activation('sigmoid', name='output_layer')(x)
return models.Model(inputs=backbone_model.input, outputs=o)
def AID_CreateModel(input_shape,
alpha_hinge=0.2,
Spatial_Dropout=False,
BN=True,
B5_FC1_neurons=1024,
similarity='simCos',
desc_dim=128,
desc_between_0_1=False,
BigDesc=False,
verbose=True):
# descriptor model
in_desc = layers.Input(shape=input_shape, name='input_patches')
x = layers.Conv2D(64, (3, 3), padding='same', name='block1_conv1')(in_desc)
if BN:
x = layers.BatchNormalization(name='block1_BN1')(x)
x = layers.Activation('relu', name='block1_relu1')(x)
x = layers.Conv2D(64, (3, 3), padding='same', name='block1_conv2')(x)
if BN:
x = layers.BatchNormalization(name='block1_BN2')(x)
x = layers.Activation('relu', name='block1_relu2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = layers.Conv2D(64, (3, 3), padding='same', name='block2_conv1')(x)
if BN:
x = layers.BatchNormalization(name='block2_BN1')(x)
x = layers.Activation('relu', name='block2_relu1')(x)
x = layers.Conv2D(64, (3, 3), padding='same', name='block2_conv2')(x)
if BN:
x = layers.BatchNormalization(name='block2_BN2')(x)
x = layers.Activation('relu', name='block2_relu2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = layers.Conv2D(128, (3, 3), padding='same', name='block3_conv1')(x)
if BN:
x = layers.BatchNormalization(name='block3_BN1')(x)
x = layers.Activation('relu', name='block3_relu1')(x)
x = layers.Conv2D(128, (3, 3), padding='same', name='block3_conv2')(x)
if BN:
x = layers.BatchNormalization(name='block3_BN2')(x)
x = layers.Activation('relu', name='block3_relu2')(x)
x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = layers.Conv2D(128, (3, 3), padding='same', name='block4_conv1')(x)
if BN:
x = layers.BatchNormalization(name='block4_BN1')(x)
x = layers.Activation('relu', name='block4_relu1')(x)
x = layers.Conv2D(128, (3, 3), padding='same', name='block4_conv2')(x)
if BigDesc == False and BN:
x = layers.BatchNormalization(name='block4_BN2')(x)
if Spatial_Dropout:
x = layers.SpatialDropout2D(p=0.5, name='block4_Dropout1')(x)
if BigDesc == False:
x = layers.Activation('relu', name='block4_relu2')(x)
# Block 5
x = layers.Flatten(name='block5_flatten1')(x)
if BigDesc == False:
if B5_FC1_neurons > 0:
x = layers.Dense(B5_FC1_neurons,
activation='relu',
name='block5_FC1')(x)
if desc_between_0_1:
x = layers.Dense(desc_dim, activation='sigmoid',
name='block5_FC2')(x)
else:
x = layers.Dense(desc_dim, name='block5_FC2')(x)
desc_model = Model(in_desc, x, name='aff_desc')
# similarity model
if similarity[0:5] == 'simFC':
if similarity[5:] == '_concat' or similarity[5:] == '_concat_BigDesc':
sim_type = 'concat'
desc_dim = 2 * desc_model.output_shape[1]
elif similarity[5:] == '_diff':
sim_type = 'diff'
# 2 siamese network
in_desc1 = layers.Input(shape=input_shape, name='input_patches1')
in_desc2 = layers.Input(shape=input_shape, name='input_patches2')
emb_1 = desc_model(in_desc1)
emb_2 = desc_model(in_desc2)
# Similarity model
in_sim = layers.Input(shape=(desc_dim, ), name='input_diff_desc')
x = layers.Dense(64, activation='relu', name='block1_FC1')(in_sim)
x = layers.Dense(32, activation='relu', name='block1_FC2')(x)
x = layers.Dense(1, activation='sigmoid', name='block1_FC3')(x)
sim_model = Model(in_sim, x, name='sim')
if sim_type == 'concat':
x = layers.Concatenate(name='Concat')([emb_1, emb_2])
else:
x = layers.Subtract(name='Subtract')([emb_1, emb_2])
out_net = sim_model(x)
# Groundtruth Model
in_GT = layers.Input(shape=(1, ), name='input_GroundTruth')
GT_model = Model(in_GT, in_GT, name='GroundTruth')
out_GT = GT_model(in_GT)
class TopLossLayerClass(layers.Layer):
def __init__(self, **kwargs):
super(TopLossLayerClass, self).__init__(**kwargs)
def call(self, inputs):
#out_net, out_GT = inputs
s, t = inputs # t=1 -> Positive class, t=0 -> Negative class
loss = K.sum(t * K.log(s) + (1 - t) * K.log(1 - s))
self.add_loss(loss)
return loss
TopLossLayer_obj = TopLossLayerClass(name='TopLossLayer')
TopLossLayer = TopLossLayer_obj([out_net, out_GT])
train_model = Model([in_desc1, in_desc2, in_GT],
TopLossLayer,
name='TrainModel')
elif similarity == 'simCos': # hinge loss
# Similarity model
desc_dim = desc_model.output_shape[1]
in_sim1 = layers.Input(shape=(desc_dim, ), name='input_desc1')
in_sim2 = layers.Input(shape=(desc_dim, ), name='input_desc2')
x = layers.Dot(axes=1, normalize=True,
name='CosineProximity')([in_sim1,
in_sim2]) # cosine proximity
sim_model = Model([in_sim1, in_sim2], x, name='sim')
# 3 siamese networks
in_desc1 = layers.Input(shape=input_shape, name='input_patches_anchor')
in_desc2 = layers.Input(shape=input_shape,
name='input_patches_positive')
in_desc3 = layers.Input(shape=input_shape,
name='input_patches_negative')
emb_1 = desc_model(in_desc1)
emb_2 = desc_model(in_desc2)
emb_3 = desc_model(in_desc3)
sim_type = 'inlist'
out_net_positive = sim_model([emb_1, emb_2])
out_net_negative = sim_model([emb_1, emb_3])
class TopLossLayerClass(layers.Layer):
def __init__(self, alpha=0.2, **kwargs):
self.alpha = alpha
super(TopLossLayerClass, self).__init__(**kwargs)
def call(self, inputs):
out_net_positive, out_net_negative = inputs
# Hinge loss computation
loss = K.sum(
K.maximum(out_net_negative - out_net_positive + self.alpha,
0)) #,axis=0)
self.add_loss(loss)
return loss
TopLossLayer_obj = TopLossLayerClass(name='TopLossLayer',
alpha=alpha_hinge)
TopLossLayer = TopLossLayer_obj([out_net_positive, out_net_negative])
train_model = Model([in_desc1, in_desc2, in_desc3],
TopLossLayer,
name='TrainModel')
if verbose:
print(
'\n\n-------> The network architecture for the affine descriptor computation !'
)
desc_model.summary()
print(
'\n\n-------> The network architecture for the similarity computation !'
)
sim_model.summary()
print('\n\n-------> Train model connections')
train_model.summary()
return train_model, sim_type
def _reduction_a_cell(ip, p, filters, block_id=None):
'''Adds a Reduction cell for NASNet-A (Fig. 4 in the paper).
# Arguments
ip: Input tensor `x`
p: Input tensor `p`
filters: Number of output filters
block_id: String block_id
# Returns
A Keras tensor
'''
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
with backend.name_scope('reduction_A_block_%s' % block_id):
p = _adjust_block(p, ip, filters, block_id)
h = layers.Activation('relu')(ip)
h = layers.Conv2D(filters, (1, 1),
strides=(1, 1),
padding='same',
kernel_regularizer=l2(weight_decay),
name='reduction_conv_1_%s' % block_id,
use_bias=False,
kernel_initializer='he_normal')(h)
if use_bn:
h = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='reduction_bn_1_%s' %
block_id)(h)
h = layers.SpatialDropout2D(drop_p)(h)
h3 = layers.ZeroPadding2D(padding=correct_pad(backend, h, 3),
name='reduction_pad_1_%s' % block_id)(h)
with backend.name_scope('block_1'):
x1_1 = _separable_conv_block(h,
filters, (5, 5),
strides=(2, 2),
block_id='reduction_left1_%s' %
block_id)
x1_2 = _separable_conv_block(p,
filters, (7, 7),
strides=(2, 2),
block_id='reduction_right1_%s' %
block_id)
x1 = layers.add([x1_1, x1_2], name='reduction_add_1_%s' % block_id)
with backend.name_scope('block_2'):
x2_1 = layers.MaxPooling2D(
(3, 3),
strides=(2, 2),
padding='valid',
name='reduction_left2_%s' % block_id)(h3)
x2_2 = _separable_conv_block(p,
filters, (7, 7),
strides=(2, 2),
block_id='reduction_right2_%s' %
block_id)
x2 = layers.add([x2_1, x2_2], name='reduction_add_2_%s' % block_id)
with backend.name_scope('block_3'):
x3_1 = layers.AveragePooling2D(
(3, 3),
strides=(2, 2),
padding='valid',
name='reduction_left3_%s' % block_id)(h3)
x3_2 = _separable_conv_block(p,
filters, (5, 5),
strides=(2, 2),
block_id='reduction_right3_%s' %
block_id)
x3 = layers.add([x3_1, x3_2], name='reduction_add3_%s' % block_id)
with backend.name_scope('block_4'):
x4 = layers.AveragePooling2D(
(3, 3),
strides=(1, 1),
padding='same',
name='reduction_left4_%s' % block_id)(x1)
x4 = layers.add([x2, x4])
with backend.name_scope('block_5'):
x5_1 = _separable_conv_block(x1,
filters, (3, 3),
block_id='reduction_left4_%s' %
block_id)
x5_2 = layers.MaxPooling2D(
(3, 3),
strides=(2, 2),
padding='valid',
name='reduction_right5_%s' % block_id)(h3)
x5 = layers.add([x5_1, x5_2], name='reduction_add4_%s' % block_id)
x = layers.concatenate([x2, x3, x4, x5],
axis=channel_dim,
name='reduction_concat_%s' % block_id)
return x, ip
def train_detector(train_gt, train_img_dir, fast_train=True):
check = callbacks.ModelCheckpoint('facepoints_model.hdf5', save_best_only = True)
picnum = len(train_gt)
if fast_train==False:
dataa = np.empty((picnum*4,px,px,3))
labells = np.empty((picnum*4,28))
else:
dataa = np.empty((picnum,px,px,3))
labells = np.empty((picnum,28))
valueff = np.empty((28))
valuef = np.empty((28))
i = 0
for key,value in train_gt.items():
im = imread(join(train_img_dir,key))
if len(im.shape) == 2:
im = np.dstack((im,im,im))
xreshape = px/im.shape[1]
yreshape = px/im.shape[0]
imr = resize(im,(px,px,3),anti_aliasing = False)
dataa[i,:,:,:] = imr
value[::2]= value[::2]*xreshape
value[1::2] = value[1::2]*yreshape
labells[i,:] = value
i+=1
if fast_train == False:
dataa[i,:,:,:] = np.fliplr(imr)
valuef[1::2] = value[1::2]
valuef[::2] = imr.shape[1] - value[::2]
valueff[0:2] = valuef[6:8]
valueff[2:4] = valuef[4:6]
valueff[4:6] = valuef[2:4]
valueff[6:8] = valuef[0:2]
valueff[8:10] = valuef[18:20]
valueff[10:12] = valuef[16:18]
valueff[12:14] = valuef[14:16]
valueff[14:16] = valuef[12:14]
valueff[16:18] = valuef[10:12]
valueff[18:20] = valuef[8:10]
valueff[20:22] = valuef[20:22]
valueff[22:24] = valuef[26:28]
valueff[24:26] = valuef[24:26]
valueff[26:28] = valuef[22:24]
labells[i,:] = valueff
print(i)
i+=1
dataa[i,:,:,:] = np.flipud(imr)
valuef[::2] = value[::2]
valuef[1::2] = imr.shape[0] - value[1::2]
valueff[0:2] = valuef[6:8]
valueff[2:4] = valuef[4:6]
valueff[4:6] = valuef[2:4]
valueff[6:8] = valuef[0:2]
valueff[8:10] = valuef[18:20]
valueff[10:12] = valuef[16:18]
valueff[12:14] = valuef[14:16]
valueff[14:16] = valuef[12:14]
valueff[16:18] = valuef[10:12]
valueff[18:20] = valuef[8:10]
valueff[20:22] = valuef[20:22]
valueff[22:24] = valuef[26:28]
valueff[24:26] = valuef[24:26]
valueff[26:28] = valuef[22:24]
labells[i,:] = valueff
print(i)
i+=1
dataa[i,:,:,:] = np.transpose(imr,(1,0,2))
valuef[::2] = value[1::2]
valuef[1::2] = value[::2]
valueff[0:2] = valuef[6:8]
valueff[2:4] = valuef[4:6]
valueff[4:6] = valuef[2:4]
valueff[6:8] = valuef[0:2]
valueff[8:10] = valuef[18:20]
valueff[10:12] = valuef[16:18]
valueff[12:14] = valuef[14:16]
valueff[14:16] = valuef[12:14]
valueff[16:18] = valuef[10:12]
valueff[18:20] = valuef[8:10]
valueff[20:22] = valuef[20:22]
valueff[22:24] = valuef[26:28]
valueff[24:26] = valuef[24:26]
valueff[26:28] = valuef[22:24]
labells[i,:] = valueff
print(i)
i+=1
for j in range (3):
mean = np.mean(dataa[:,:,:,j],axis = 0)
std = np.std(dataa[:,:,:,j],axis = 0)
for i in range(len(dataa)):
dataa[i,:,:,j] = (dataa[i,:,:,j]-mean)/std
model = Sequential()
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(24,(5,5),data_format="channels_last",activation='relu',input_shape = (px,px,3)))
model.add(layers.MaxPooling2D())
model.add(layers.BatchNormalization())
model.add(layers.SpatialDropout2D(0.2))
model.add(layers.Conv2D(36,(5,5),data_format="channels_last",activation='relu'))
model.add(layers.MaxPooling2D())
model.add(layers.BatchNormalization())
model.add(layers.SpatialDropout2D(0.2))
model.add(layers.Conv2D(48,(5,5),data_format="channels_last",activation='relu'))
model.add(layers.MaxPooling2D(padding = 'same'))
model.add(layers.BatchNormalization())
model.add(layers.SpatialDropout2D(0.2))
model.add(layers.Conv2D(128,(3,3),data_format="channels_last",activation='relu'))
model.add(layers.MaxPooling2D(padding = 'same'))
model.add(layers.BatchNormalization())
model.add(layers.SpatialDropout2D(0.2))
model.add(layers.Conv2D(128,(3,3),data_format="channels_last",padding = 'same',activation='relu'))
model.add(layers.MaxPooling2D())
model.add(layers.BatchNormalization())
model.add(layers.SpatialDropout2D(0.2))
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dense(500, activation='relu'))
model.add(layers.Dense(84, activation='relu'))
model.add(layers.Dense(28))
model.compile(optimizer='Adam',
loss='mse',
metrics=['accuracy'])
if fast_train == True:
model.fit(dataa, labells, batch_size=1000, epochs=1)
model.save('facepoints_model.hdf5')
else:
model.fit(dataa, labells, batch_size=128, epochs=800,validation_split = 0.2, callbacks = ([check]))
def FashionCapsNet(input_shape, n_class, args):
x = layers.Input(shape=input_shape)
def residual_block(y, nb_channels, _strides=(2, 2), _project_shortcut=False):
shortcut = y
# down-sampling is performed with a stride of 2
y = layers.Conv2D(nb_channels, kernel_size=(3, 3), strides=_strides, padding='same')(y)
y = layers.BatchNormalization()(y)
y = layers.LeakyReLU()(y)
y = layers.Conv2D(nb_channels, kernel_size=(3, 3), strides=(1, 1), padding='same')(y)
y = layers.BatchNormalization()(y)
# identity shortcuts used directly when the input and output are of the same dimensions
if _project_shortcut or _strides != (1, 1):
# when the dimensions increase projection shortcut is used to match dimensions (done by 1×1 convolutions)
# when the shortcuts go across feature maps of two sizes, they are performed with a stride of 2
shortcut = layers.Conv2D(nb_channels, kernel_size=(1, 1), strides=_strides, padding='same')(shortcut)
shortcut = layers.BatchNormalization()(shortcut)
y = layers.add([shortcut, y])
y = layers.LeakyReLU()(y)
return y
# Stacked-convolutional layer 1
out = layers.Conv2D(filters=32, kernel_size=7, strides=1, padding='same', name='conv1_1')(x)
out = layers.BatchNormalization()(out)
out = layers.LeakyReLU()(out)
out = layers.SpatialDropout2D(rate=0.3)(out)
out = residual_block(out, nb_channels=64, _project_shortcut=True)
out = layers.SpatialDropout2D(rate=0.3)(out)
out = residual_block(out, nb_channels=128, _project_shortcut=True)
out = layers.SpatialDropout2D(rate=0.3)(out)
out = residual_block(out, nb_channels=256, _project_shortcut=True)
out = layers.SpatialDropout2D(rate=0.3)(out)
# PrimaryCaps
out = PrimaryCaps(out, dim_capsule=args.dim_capsule)
# FashionCaps
out = FashionCaps(num_capsule=n_class, dim_capsule=args.dim_capsule,
routings=args.routings, name='fashioncaps')(out)
# Length of each capsule represents the probability of the existence of the entity
out_caps = Length(name='capsnet')(out)
# Mask the output of FashionCapsNet
y = layers.Input(shape=(n_class,))
masked_by_y = Mask()([out, y]) # The true label is used to mask the output of capsule layer. For training
masked = Mask()(out) # Mask using the capsule with maximal length. For prediction
# Transpose-convolutional decoder network for reconstruction
decoder = models.Sequential(name='decoder')
decoder.add(layers.Dense(7*7*args.conv_filters, activation='relu', input_dim=args.dim_capsule*n_class))
decoder.add(layers.Reshape((7, 7, args.conv_filters)))
decoder.add(layers.Conv2DTranspose(args.conv_filters, kernel_size=4, strides=2, padding='same'))
decoder.add(layers.BatchNormalization(axis=-1))
decoder.add(layers.LeakyReLU())
decoder.add(layers.Conv2DTranspose(int(args.conv_filters/2), kernel_size=4, strides=2, padding='same'))
decoder.add(layers.BatchNormalization(axis=-1))
decoder.add(layers.LeakyReLU())
decoder.add(layers.Conv2DTranspose(int(args.conv_filters / 4), kernel_size=4, strides=2, padding='same'))
decoder.add(layers.BatchNormalization(axis=-1))
decoder.add(layers.LeakyReLU())
decoder.add(layers.Conv2DTranspose(int(args.conv_filters / 8), kernel_size=4, strides=2, padding='same'))
decoder.add(layers.BatchNormalization(axis=-1))
decoder.add(layers.LeakyReLU())
decoder.add(layers.Conv2DTranspose(3, kernel_size=4, strides=2, padding='same', activation='sigmoid'))
# Model for training
train_model = models.Model([x, y], [out_caps, decoder(masked_by_y)])
# Model for evaluation
eval_model = models.Model(x, [out_caps, decoder(masked)])
return train_model, eval_model
return layers.Activation('elu')(y)
in_layer = layers.Input(t_x.shape[1:], name = 'RGB_Input')
pp_in_layer = layers.GaussianNoise(GAUSSIAN_NOISE)(in_layer)
pp_in_layer = layers.BatchNormalization()(pp_in_layer)
c = conv_bn(pp_in_layer, BASE_DEPTH//2)
c = conv_bn(c, BASE_DEPTH//2)
c = conv_bn(c, BASE_DEPTH)
skip_layers = [pp_in_layer]
for j in range(BLOCK_COUNT):
depth_steps = int(np.log2(t_x.shape[1])-2)
d = layers.concatenate(skip_layers+[conv_bn(c, BASE_DEPTH*2**j, (2**i, 2**i), preblock=True)
for i in range(depth_steps)])
d = layers.SpatialDropout2D(SPATIAL_DROPOUT)(d)
d = layers.BatchNormalization()(d)
d = layers.Activation('elu')(d)
# bottleneck
d = conv_bn(d, BASE_DEPTH*2**(j+1))
skip_layers += [c]
c = d
d = layers.Convolution2D(1, (1, 1), activation='sigmoid', padding='same')(d)
d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d)
d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d)
seg_model = models.Model(inputs = [in_layer],
outputs = [d])
seg_model.summary()
# %% [code]
import keras.backend as K
def UNetCapsuleNetClippedModel(self, n_class=4, number_of_channel=3):
shape_default = (self.input_shape[0], self.input_shape[1], number_of_channel)
x = layers.Input(shape=shape_default)
# 56x56 Level 3
n_filter = 512
conv_level_3 = utils.Conv2DBNSLU(x=x, filters=32, kernel_size=1, strides=1,
padding='valid', activation='selu', name='conv_level_3_0')
print(conv_level_3.shape)
# 28x28 Level 2
conv_level_2 = layers.Conv2D(filters=64, kernel_size=2, strides=2,
padding='same', activation='selu', name='conv_level_2')(conv_level_3)
conv_level_2 = layers.SpatialDropout2D(0.2)(conv_level_2)
# 14x14
conv_level_1 = layers.Conv2D(filters=128, kernel_size=2, strides=1, padding='same', activation='selu',
name='conv_level_1')(conv_level_2)
conv_level_1 = layers.SpatialDropout2D(0.2)(conv_level_1)
conv_level_1 = layers.MaxPooling2D(pool_size=(2, 2), name='pool_level_1')(conv_level_1)
# subgroups
conv_level_1_7 = layers.Conv2D(filters=128, kernel_size=7, strides=1, padding='same', activation='selu',
name='conv_level_1_7')(conv_level_1)
conv_level_1_7 = layers.SpatialDropout2D(0.2)(conv_level_1_7)
conv_level_1_5 = layers.Conv2D(filters=128, kernel_size=5, strides=1, padding='same', activation='selu',
name='conv_level_1_5')(conv_level_1)
conv_level_1_5 = layers.SpatialDropout2D(0.2)(conv_level_1_5)
conv_level_1_3 = layers.Conv2D(filters=128, kernel_size=(3, 5), strides=1, padding='same', activation='selu',
name='conv_level_1_3')(conv_level_1)
conv_level_1_3 = layers.SpatialDropout2D(0.2)(conv_level_1_3)
# Concatenate
conv_level_1 = concatenate([conv_level_1,
conv_level_1_5,
conv_level_1_3,
conv_level_1_7])
# 7x7
conv_level_0 = layers.Conv2D(filters=256, kernel_size=2, strides=2,
padding='valid', activation='selu', name='conv_level_0')(conv_level_1)
# Contour detection
conv_level_0_31 = layers.Conv2D(filters=64, kernel_size=(3, 1), strides=1,
padding='same', activation='selu', name='conv_level_0_13')(conv_level_0)
conv_level_0_31 = layers.SpatialDropout2D(0.2)(conv_level_0_31)
conv_level_0_3 = layers.Conv2D(filters=64, kernel_size=3, strides=1,
padding='same', activation='selu', name='conv_level_0_3')(conv_level_0)
conv_level_0_3 = layers.SpatialDropout2D(0.2)(conv_level_0_3)
conv_level_0_5 = layers.Conv2D(filters=64, kernel_size=5, strides=1,
padding='same', activation='selu', name='conv_level_0_5')(conv_level_0)
conv_level_0_5 = layers.SpatialDropout2D(0.2)(conv_level_0_5)
conv_level_0 = concatenate([conv_level_0, conv_level_0_3, conv_level_0_31, conv_level_0_5])
# Upsampling from level 0 to level 1; 7 --> 14
upsample_level_0_to_1 = keras.layers.UpSampling2D(size=(2, 2), data_format=None)(conv_level_0)
conv_level_0_to_1 = concatenate([upsample_level_0_to_1, conv_level_1])
# Upsampling from level 1 to level 2; 14 --> 28
upsample_level_1_to_2 = keras.layers.UpSampling2D(size=(2, 2), data_format=None)(conv_level_0_to_1)
conv_level_0_to_2 = concatenate([upsample_level_1_to_2, conv_level_2])
# Reduce the number of filter by half
# filter_size = int(conv_level_0_to_2.shape[3])
# filter_size = int(round(filter_size * 0.8))
# filter_size = filter_size - int(conv_level_3.shape[3])
# reduction_level = layers.Conv2D(filter_size, kernel_size=1, strides=1, padding='same', activation='relu', name='reduction_level')(conv_level_0_to_2)
# Upsampling from level 2 to level 3; 28 --> 56
upsample_level_2_to_3 = keras.layers.UpSampling2D(size=(2, 2), data_format=None)(conv_level_0_to_2)
conv_level_0_to_2_to_3 = concatenate([upsample_level_2_to_3, conv_level_3])
filter_layers = layers.Conv2D(filters=n_filter, kernel_size=3, strides=1,
padding='same', activation='selu', name='filter_layer')(conv_level_0_to_2_to_3)
one_hot_layer = layers.Conv2D(filters=n_class, kernel_size=1, strides=1,
padding='same', activation='softmax', name='ucnet')(filter_layers)
y = layers.Input(shape=(self.input_shape[0], self.input_shape[1], n_class))
reshaped_filter_layers = layers.Reshape((n_filter, self.input_shape[0] * self.input_shape[1]),
input_shape=(self.input_shape[0], self.input_shape[1], n_filter))(
filter_layers)
# train condition
mask_with_y = custom_layers.MaskFilter(num_classes=n_class, train_mode=True)([reshaped_filter_layers, y])
mask_without_y = custom_layers.MaskFilter(num_classes=n_class, train_mode=False)(
[filter_layers, reshaped_filter_layers, one_hot_layer])
reshaped_y_train = layers.Reshape((self.input_shape[0] * self.input_shape[1], n_class),
input_shape=(self.input_shape[0], self.input_shape[1], n_class))(y)
masked_filters_train = K.batch_dot(reshaped_filter_layers, reshaped_y_train)
masked_filters_train = layers.Flatten()(masked_filters_train)
# test/prediction condition
one_hot_layer_reshaped = layers.Reshape((n_class, self.input_shape[0] * self.input_shape[1]),
input_shape=(self.input_shape[0], self.input_shape[1], n_class))(
one_hot_layer)
reshaped_y_test = K.one_hot(indices=K.argmax(one_hot_layer_reshaped, 1), num_classes=n_class)
masked_filters_test = K.batch_dot(reshaped_filter_layers, reshaped_y_test)
masked_filters_test = layers.Flatten()(masked_filters_test)
print('masked_filters_test', masked_filters_test)
print('masked_filters_train', masked_filters_train)
# Shared Decoder model in training and prediction
shape_default_mask = (shape_default[0], shape_default[1], n_class)
decoder = models.Sequential(name='decoder')
decoder.add(layers.Dense(512, activation='selu', input_dim=(n_filter * n_class))) # 1024
decoder.add(layers.Dense(1024, activation='selu')) # 2048
decoder.add(layers.Dense(np.prod(shape_default_mask), activation='sigmoid'))
decoder.add(layers.Reshape(target_shape=shape_default_mask, name='out_recon'))
train_model = models.Model([x, y], [one_hot_layer, decoder(mask_with_y)])
eval_model = models.Model(x, one_hot_layer)
# eval_model = models.Model(x, [one_hot_layer, decoder(mask_without_y)])
'''
train_model = models.Model(x,one_hot_layer)
eval_model = models.Model(x, one_hot_layer)
'''
return train_model, eval_model
def UNet(input_shape=(None, None, 1),
conv_layers_dimensions=(16, 32, 64, 128),
base_conv_layers_dimensions=(128, 128),
output_conv_layers_dimensions=(16, 16),
dropout=(),
steps_per_pooling=1,
number_of_outputs=1,
output_activation=None,
loss=nd_mean_absolute_error,
layer_function=None,
**kwargs):
"""Creates and compiles a U-Net.
Parameters
----------
input_shape : tuple of ints
Size of the images to be analyzed.
conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer during down-
and upsampling.
base_conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer at the base
of the unet, where the image is the most downsampled.
output_conv_layers_dimensions : tuple of ints
Number of convolutions in each convolutional layer after the
upsampling.
steps_per_pooling : int
Number of convolutional layers between each pooling and upsampling
step.
number_of_outputs : int
Number of convolutions in output layer.
output_activation : str or keras activation
The activation function of the output.
loss : str or keras loss function
The loss function of the network.
layer_function : Callable[int] -> keras layer
Function that returns a convolutional layer with convolutions
determined by the input argument. Can be use to futher customize the network.
Returns
-------
keras.models.Model
Deep learning network.
"""
if layer_function is None:
layer_function = lambda dimensions: layers.Conv2D(
dimensions, kernel_size=3, activation="relu", padding="same")
unet_input = layers.Input(input_shape)
concat_layers = []
layer = unet_input
# Downsampling step
for conv_layer_dimension in conv_layers_dimensions:
for _ in range(steps_per_pooling):
layer = layer_function(conv_layer_dimension)(layer)
concat_layers.append(layer)
if dropout:
layer = layers.SpatialDropout2D(dropout[0])(layer)
dropout = dropout[1:]
layer = layers.MaxPooling2D(2)(layer)
# Base steps
for conv_layer_dimension in base_conv_layers_dimensions:
layer = layer_function(conv_layer_dimension)(layer)
# Upsampling step
for conv_layer_dimension, concat_layer in zip(
reversed(conv_layers_dimensions), reversed(concat_layers)):
layer = layers.Conv2DTranspose(conv_layer_dimension,
kernel_size=2,
strides=2)(layer)
layer = layers.Concatenate(axis=-1)([layer, concat_layer])
for _ in range(steps_per_pooling):
layer = layer_function(conv_layer_dimension)(layer)
# Output step
for conv_layer_dimension in output_conv_layers_dimensions:
layer = layer_function(conv_layer_dimension)(layer)
layer = layers.Conv2D(number_of_outputs,
kernel_size=3,
activation=output_activation,
padding="same")(layer)
model = models.Model(unet_input, layer)
return KerasModel(model, loss=loss, **kwargs)
def finger_field_injection(dropout_rate=0.0, activation=kl.activations.relu, train_mobilenet=False):
# net_in = kl.Input(shape=[224, 224, 3], name=IN('img'))
# print(net_in._op.__dict__)
mobile_net = MobileNet(include_top=False,
weights='imagenet',
dropout=dropout_rate,
# input_tensor=net_in._op,
input_shape=[224, 224, 3])
layers = mobile_net.layers[:26]
for layer in layers:
layer.trainable = train_mobilenet
layers[0].name = IN('img')
transferred_net = km.Sequential(layers=layers)
# alternative path from input
c_alt = kl.Conv2D(filters=128, kernel_size=[7, 7], padding='same', activation=activation)(transferred_net.input)
c_alt = kl.Conv2D(filters=256, kernel_size=[5, 5], padding='same', activation=activation)(c_alt)
c_alt = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(c_alt)
c_alt = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(c_alt)
c_alt = kl.MaxPool2D(padding='same', pool_size=(2, 2))(c_alt)
c_alt = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_alt)
c_alt = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_alt)
c_alt = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_alt)
c_alt = kl.Conv2D(filters=transferred_net.output_shape[-1], kernel_size=[3, 3], padding='same', activation=activation)(c_alt)
c_alt = kl.MaxPool2D(padding='same', pool_size=(2, 2))(c_alt)
base_in = kl.concatenate([transferred_net.output, c_alt], axis=-1)
c1 = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(base_in)
c1 = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(c1)
c1 = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c1)
c_vec = kl.Conv2D(filters=256, kernel_size=[3, 3], padding='same', activation=activation)(base_in)
c_vec = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_vec)
c_vec = kl.Lambda(lambda x: x[:, 5:-5, 5:-5, :])(c_vec)
c_vec_out_a = kl.Conv2D(filters=10, kernel_size=[3, 3], padding='same', activation='sigmoid')(c_vec)
c_vec_out_b = kl.Conv2D(filters=10, kernel_size=[3, 3], padding='same', activation='sigmoid')(c_vec)
c_vec_out = kl.subtract([c_vec_out_a, c_vec_out_b], name=OUT('field'))
c_vec = kl.ZeroPadding2D(padding=(5, 5))(c_vec_out)
c_vec = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c_vec)
c2_in = kl.concatenate([c1, c_vec], axis=-1)
c2 = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c2_in)
c2 = kl.Conv2D(filters=128, kernel_size=[3, 3], padding='same', activation=activation)(c2)
d2 = kl.SpatialDropout2D(rate=dropout_rate)(c2)
c3 = kl.Conv2D(filters=64, kernel_size=[3, 3], padding='valid', activation=activation)(d2)
c3 = kl.Lambda(lambda x: x[:, 5:-5, 5:-5, :])(c3)
c3 = kl.Conv2D(filters=21, kernel_size=[3, 3], padding='valid', activation='sigmoid', name=OUT('heat'))(c3)
# before the fully connected is built, cut down the dimensionality of the data
bfc1 = kl.MaxPool2D(padding='valid', pool_size=(2, 2))(d2)
bfc2 = kl.Conv2D(filters=32, kernel_size=[3, 3], padding='valid', activation=activation)(bfc1)
base_fc = kl.Flatten()(bfc2)
fc1 = kl.Dense(units=32, activation=activation)(base_fc)
fc2 = kl.Dense(units=21, activation='sigmoid', name=OUT('vis'))(fc1)
model = km.Model(inputs=(transferred_net.input,), outputs=(c3, fc2, c_vec_out))
return model
shuffle=False,
class_mode=None,
target_size=(300, 300))
input_1 = Input(shape=(300, 300, 3), dtype='float32', name='egal')
# This is module with image preprocessing utilities
z = layers.Dense(32, activation='tanh', input_shape=(300, 300, 3))(input_1)
z = layers.MaxPooling2D((3, 3))(z)
a_1 = layers.SeparableConv2D(64, (3, 3), activation='tanh', padding='same')(z)
b_1 = layers.SeparableConv2D(64, (7, 7), activation='tanh', padding='same')(z)
c_1 = layers.SeparableConv2D(64, (5, 5), activation='tanh', padding='same')(z)
z = layers.concatenate([a_1, b_1, c_1])
z = layers.Conv2D(64, (1, 1))(z)
z = layers.SpatialDropout2D(0.2)(z)
z = layers.MaxPooling2D((3, 3))(z)
a_2 = layers.SeparableConv2D(128, (5, 5), activation='tanh', padding='same')(z)
d_2 = layers.GlobalMaxPooling2D()(a_2)
b_2 = layers.SeparableConv2D(128, (7, 7), activation='tanh', padding='same')(z)
e_2 = layers.GlobalMaxPooling2D()(b_2)
c_2 = layers.SeparableConv2D(128, (9, 9), activation='tanh', padding='same')(z)
f_2 = layers.GlobalMaxPooling2D()(c_2)
z = layers.concatenate([a_2, b_2, c_2])
x = layers.concatenate([d_2, e_2, f_2])
z = layers.multiply([z, x])
z = layers.Conv2D(128, (1, 1))(z)
z = layers.MaxPooling2D((3, 3))(z)
a_3 = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z)
z = layers.SpatialDropout2D(0.2)(a_3)
z = layers.SeparableConv2D(256, (3, 3), activation='tanh', padding='same')(z)
def mb_conv_block(inputs,
block_args,
activation,
drop_rate=None,
prefix='',
spatial_dropout=False):
"""Mobile Inverted Residual Bottleneck."""
has_se = (block_args.se_ratio
is not None) and (0 < block_args.se_ratio <= 1)
bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1
# workaround over non working dropout with None in noise_shape in tf.keras
Dropout = get_dropout(backend=backend,
layers=layers,
models=models,
utils=keras_utils)
# Expansion phase
filters = block_args.input_filters * block_args.expand_ratio
if block_args.expand_ratio != 1:
x = layers.Conv2D(filters,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'expand_conv')(inputs)
x = layers.BatchNormalization(axis=bn_axis,
name=prefix + 'expand_bn')(x)
x = layers.Activation(activation, name=prefix + 'expand_activation')(x)
else:
x = inputs
# Depthwise Convolution
x = layers.DepthwiseConv2D(block_args.kernel_size,
strides=block_args.strides,
padding='same',
use_bias=False,
depthwise_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'dwconv')(x)
if spatial_dropout:
x = layers.SpatialDropout2D(0.5)(x)
x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'bn')(x)
x = layers.Activation(activation, name=prefix + 'activation')(x)
# Squeeze and Excitation phase
if has_se:
num_reduced_filters = max(
1, int(block_args.input_filters * block_args.se_ratio))
se_tensor = layers.GlobalAveragePooling2D(name=prefix +
'se_squeeze')(x)
target_shape = (
1, 1,
filters) if backend.image_data_format() == 'channels_last' else (
filters, 1, 1)
se_tensor = layers.Reshape(target_shape,
name=prefix + 'se_reshape')(se_tensor)
se_tensor = layers.Conv2D(num_reduced_filters,
1,
activation=activation,
padding='same',
use_bias=True,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'se_reduce')(se_tensor)
se_tensor = layers.Conv2D(filters,
1,
activation='sigmoid',
padding='same',
use_bias=True,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'se_expand')(se_tensor)
if backend.backend() == 'theano':
# For the Theano backend, we have to explicitly make
# the excitation weights broadcastable.
pattern = ([True, True, True, False]
if backend.image_data_format() == 'channels_last' else
[True, False, True, True])
se_tensor = layers.Lambda(
lambda x: backend.pattern_broadcast(x, pattern),
name=prefix + 'se_broadcast')(se_tensor)
x = layers.multiply([x, se_tensor], name=prefix + 'se_excite')
# Output phase
x = layers.Conv2D(block_args.output_filters,
1,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
name=prefix + 'project_conv')(x)
x = layers.BatchNormalization(axis=bn_axis, name=prefix + 'project_bn')(x)
if block_args.id_skip and all(
s == 1 for s in block_args.strides
) and block_args.input_filters == block_args.output_filters:
if drop_rate and (drop_rate > 0):
x = Dropout(drop_rate,
noise_shape=(None, 1, 1, 1),
name=prefix + 'drop')(x)
x = layers.add([x, inputs], name=prefix + 'add')
return x
def run(seg1_path, seg2_path, batch_size, lr, dropout_rate, data_path,
artifacts_folder, img_size, seed, _run):
artifacts_folder = Path(artifacts_folder)
artifacts_folder.mkdir(parents=True, exist_ok=True)
data_path = Path(data_path)
data_df = pd.read_csv(data_path / 'train.csv')
data_df = prepare_data_df(data_df)
print(data_df.info())
print(data_df.head(10))
train_df, val_df = train_test_split(data_df,
test_size=0.2,
random_state=seed)
train_df = train_df.sample(frac=1).reset_index(drop=True)
ckpt_path = artifacts_folder / 'ckpts'
ckpt_path.mkdir(exist_ok=True, parents=True)
seg1_model = models.load_model(seg1_path, compile=False)
for layer in seg1_model.layers:
layer.name = f'seg1_{layer.name}'
layer.trainable = False
seg2_model = models.load_model(seg2_path, compile=False)
for layer in seg2_model.layers:
layer.name = f'seg2_{layer.name}'
layer.trainable = False
x = layers.concatenate([seg1_model.output, seg2_model.output])
x = layers.SpatialDropout2D(dropout_rate)(x)
x = conv(x, 16, 3)
x = layers.Conv2D(4, (1, 1))(x)
o = layers.Activation('sigmoid', name='output_layer')(x)
segmentation_model = models.Model([seg1_model.input, seg2_model.input], o)
segmentation_model.compile(
optimizers.Adam(lr),
sm.losses.bce_dice_loss,
metrics=[sm.metrics.iou_score, sm.metrics.f1_score])
utils.plot_model(segmentation_model,
str(artifacts_folder / 'seg_model.png'),
show_shapes=True)
training_callbacks = [
callbacks.ReduceLROnPlateau(patience=3, verbose=1, min_lr=1e-7),
callbacks.EarlyStopping(patience=5,
verbose=1,
restore_best_weights=True),
callbacks.ModelCheckpoint(str(
ckpt_path / 'seg_model-{epoch:04d}-{val_loss:.4f}.hdf5'),
verbose=1,
save_best_only=True),
callbacks.TensorBoard(log_dir=str(artifacts_folder / 'tb_logs')),
callbacks.TerminateOnNaN(),
ObserveMetrics(_run, 'seg')
]
train_seq = DataSequence(seed,
train_df,
batch_size,
img_size,
'data/train_images',
mode='train',
shuffle=True,
augment=True,
for_stacker=True)
val_seq = DataSequence(seed,
val_df,
batch_size,
img_size,
'data/train_images',
mode='val',
shuffle=False,
augment=False,
for_stacker=True)
history = train_model(segmentation_model, train_seq, val_seq,
training_callbacks)
models.save_model(segmentation_model,
str(artifacts_folder / 'seg_model_best.h5'))
segmentation_model.save_weights(
str(artifacts_folder / 'weights_seg_model_best.h5'))
print('loading model back')
del segmentation_model
segmentation_model = models.load_model(str(artifacts_folder /
'seg_model_best.h5'),
compile=False)
segmentation_model.predict_generator(val_seq, verbose=1)
return history.history['val_loss'][-1]
def _separable_conv_block(ip,
filters,
kernel_size=(3, 3),
strides=(1, 1),
block_id=None):
'''Adds 2 blocks of [relu-separable conv-batchnorm].
# Arguments
ip: Input tensor
filters: Number of output filters per layer
kernel_size: Kernel size of separable convolutions
strides: Strided convolution for downsampling
block_id: String block_id
# Returns
A Keras tensor
'''
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
with backend.name_scope('separable_conv_block_%s' % block_id):
x = layers.Activation('relu')(ip)
if strides == (2, 2):
x = layers.ZeroPadding2D(
padding=correct_pad(backend, x, kernel_size),
name='separable_conv_1_pad_%s' % block_id)(x)
conv_pad = 'valid'
else:
conv_pad = 'same'
x = layers.SeparableConv2D(filters,
kernel_size,
strides=strides,
name='separable_conv_1_%s' % block_id,
padding=conv_pad,
use_bias=False,
depthwise_regularizer=l2(weight_decay),
pointwise_regularizer=l2(weight_decay),
kernel_initializer='he_normal')(x)
if use_bn:
x = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='separable_conv_1_bn_%s' %
(block_id))(x)
x = layers.SpatialDropout2D(drop_p)(x)
x = layers.Activation('relu')(x)
x = layers.SeparableConv2D(filters,
kernel_size,
name='separable_conv_2_%s' % block_id,
padding='same',
use_bias=False,
depthwise_regularizer=l2(weight_decay),
pointwise_regularizer=l2(weight_decay),
kernel_initializer='he_normal')(x)
if use_bn:
x = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='separable_conv_2_bn_%s' %
(block_id))(x)
x = layers.SpatialDropout2D(drop_p)(x)
return x
base_pretrained_model = PTModel(input_shape=t_x.shape[1:],
include_top=False,
weights='imagenet')
base_pretrained_model.trainable = False
# In[ ]:
from keras import models, layers
from keras.optimizers import Adam
img_in = layers.Input(t_x.shape[1:], name='Image_RGB_In')
img_noise = layers.GaussianNoise(GAUSSIAN_NOISE)(img_in)
pt_features = base_pretrained_model(img_noise)
pt_depth = base_pretrained_model.get_output_shape_at(0)[-1]
bn_features = layers.BatchNormalization()(pt_features)
feature_dropout = layers.SpatialDropout2D(DROPOUT)(bn_features)
gmp_dr = layers.GlobalMaxPooling2D()(feature_dropout)
dr_steps = layers.Dropout(DROPOUT)(layers.Dense(DENSE_COUNT,
activation='relu')(gmp_dr))
out_layer = layers.Dense(1, activation='sigmoid')(dr_steps)
ship_model = models.Model(inputs=[img_in],
outputs=[out_layer],
name='full_model')
ship_model.compile(optimizer=Adam(lr=LEARN_RATE),
loss='binary_crossentropy',
metrics=['binary_accuracy'])
# In[ ]:
def _adjust_block(p, ip, filters, block_id=None):
'''Adjusts the input `previous path` to match the shape of the `input`.
Used in situations where the output number of filters needs to be changed.
# Arguments
p: Input tensor which needs to be modified
ip: Input tensor whose shape needs to be matched
filters: Number of output filters to be matched
block_id: String block_id
# Returns
Adjusted Keras tensor
'''
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
img_dim = 2 if backend.image_data_format() == 'channels_first' else -2
ip_shape = backend.int_shape(ip)
if p is not None:
p_shape = backend.int_shape(p)
with backend.name_scope('adjust_block'):
if p is None:
p = ip
elif p_shape[img_dim] != ip_shape[img_dim]:
with backend.name_scope('adjust_reduction_block_%s' % block_id):
p = layers.Activation('relu',
name='adjust_relu_1_%s' % block_id)(p)
p1 = layers.AveragePooling2D(
(1, 1),
strides=(2, 2),
padding='valid',
name='adjust_avg_pool_1_%s' % block_id)(p)
p1 = layers.Conv2D(filters // 2, (1, 1),
padding='same',
kernel_regularizer=l2(weight_decay),
use_bias=False,
name='adjust_conv_1_%s' % block_id,
kernel_initializer='he_normal')(p1)
p2 = layers.ZeroPadding2D(padding=((0, 1), (0, 1)))(p)
p2 = layers.Cropping2D(cropping=((1, 0), (1, 0)))(p2)
p2 = layers.AveragePooling2D(
(1, 1),
strides=(2, 2),
padding='valid',
name='adjust_avg_pool_2_%s' % block_id)(p2)
p2 = layers.Conv2D(filters // 2, (1, 1),
padding='same',
kernel_regularizer=l2(weight_decay),
use_bias=False,
name='adjust_conv_2_%s' % block_id,
kernel_initializer='he_normal')(p2)
p = layers.concatenate([p1, p2], axis=channel_dim)
if use_bn:
p = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='adjust_bn_%s' %
block_id)(p)
p = layers.SpatialDropout2D(drop_p)(p)
elif p_shape[channel_dim] != filters:
with backend.name_scope('adjust_projection_block_%s' % block_id):
p = layers.Activation('relu')(p)
p = layers.Conv2D(filters, (1, 1),
strides=(1, 1),
kernel_regularizer=l2(weight_decay),
padding='same',
name='adjust_conv_projection_%s' % block_id,
use_bias=False,
kernel_initializer='he_normal')(p)
if use_bn:
p = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='adjust_bn_%s' %
block_id)(p)
p = layers.SpatialDropout2D(drop_p)(p)
return p
def D3GenerateModel(n_filter=16,
number_of_class=1,
input_shape=(16, 144, 144, 1),
activation_last='softmax',
metrics=[
'mse', 'acc', dice_coef, recall_at_thresholds,
precision_at_thresholds
],
loss='kullback_leibler_divergence',
dropout=0.05,
init='glorot_uniform',
two_output=False):
#init = initializers.VarianceScaling(scale=1.0, mode='fan_in', distribution='normal', seed=None)
filter_size = n_filter
input_x = layers.Input(shape=input_shape,
name='Input_layer',
dtype='float32')
#1 level
x = layers.Conv3D(filters=filter_size,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
kernel_initializer=init,
padding='same')(input_x)
x = cyclical_learning_rate.SineReLU()(x)
x = layers.Conv3D(filters=filter_size,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
padding='same',
kernel_initializer=init)(x)
x = cyclical_learning_rate.SineReLU()(x)
x = layers.MaxPooling3D(pool_size=(2, 2, 2), padding='same')(x)
#2 level
conv_list = []
counter = 0
x = layers.Conv3D(filters=filter_size * 2,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
padding='same',
kernel_initializer=init)(x)
x = cyclical_learning_rate.SineReLU()(x)
x = layers.MaxPooling3D(pool_size=(1, 2, 2), padding='same')(x)
x = layers.UpSampling3D(size=(1, 2, 2))(x)
for index, kernel_sizes in enumerate([
[(1, 3, 3), (3, 3, 1)], #Changed [(1,3,3), (1,1,3)]
[(3, 3, 3), (3, 1, 3)], #Changed [(3,3,3), (3,1,3)]
[(3, 3, 1), (3, 3, 3), (1, 3, 3)] #Changed [(3,3,1), (1,3,1)]
]):
for kernel_size in (kernel_sizes):
x = layers.Conv3D(filters=(filter_size * 4),
kernel_size=kernel_size,
kernel_initializer=init,
strides=(1, 1, 1),
padding='same',
name='Conv3D_%s' % (counter))(x)
x = layers.BatchNormalization()(x)
x = cyclical_learning_rate.SineReLU()(x)
counter = counter + 1
conv_list.append(x)
x = layers.add(conv_list)
x = layers.Conv3D(filters=filter_size * 4,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
kernel_initializer=init,
padding='same')(x)
x = layers.Reshape(target_shape=[4, -1, filter_size * 4])(x)
x = layers.Conv2D(filters=filter_size * 4,
kernel_size=(1, 1296),
kernel_initializer=init,
strides=(1, 1296))(x)
x = layers.SpatialDropout2D(0.01)(x)
x = cyclical_learning_rate.SineReLU()(x)
x = layers.Reshape(target_shape=[filter_size * 4, -1])(x)
x = layers.Conv1D(filters=2,
kernel_size=filter_size * 4,
strides=filter_size * 4,
kernel_initializer=init,
kernel_regularizer=l2(0.001))(x)
x = layers.Softmax()(x)
y = layers.Flatten()(x)
#Classification
model = Model(inputs=input_x, outputs=y)
#optimizer = tf.contrib.opt.AdamWOptimizer(weight_decay=0.000001,lr=lr)
#keras.optimizers.SGD(lr=lr, momentum=0.90, decay=decay, nesterov=False)
#opt_noise = add_gradient_noise(optimizers.Adam)
#optimizer = 'Adam'#opt_noise(lr, amsgrad=True)#, nesterov=True)#opt_noise(lr, amsgrad=True)
import yogi
optimizer = yogi.Yogi(lr=lr)
#optimizer=optimizers.adam(lr, amsgrad=True)
model.compile(optimizer=optimizer, loss=loss,
metrics=metrics) #categorical_crossentropy
return model
def NASNet(input_shape=None,
penultimate_filters=4032,
num_blocks=6,
stem_block_filters=96,
skip_reduction=True,
filter_multiplier=2,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=1000,
default_size=None,
**kwargs):
'''Instantiates a NASNet model.
Optionally loads weights pre-trained on ImageNet.
Note that the data format convention used by the model is
the one specified in your Keras config at `~/.keras/keras.json`.
# Arguments
input_shape: Optional shape tuple, the input shape
is by default `(331, 331, 3)` for NASNetLarge and
`(224, 224, 3)` for NASNetMobile.
It should have exactly 3 input channels,
and width and height should be no smaller than 32.
E.g. `(224, 224, 3)` would be one valid value.
penultimate_filters: Number of filters in the penultimate layer.
NASNet models use the notation `NASNet (N @ P)`, where:
- N is the number of blocks
- P is the number of penultimate filters
num_blocks: Number of repeated blocks of the NASNet model.
NASNet models use the notation `NASNet (N @ P)`, where:
- N is the number of blocks
- P is the number of penultimate filters
stem_block_filters: Number of filters in the initial stem block
skip_reduction: Whether to skip the reduction step at the tail
end of the network.
filter_multiplier: Controls the width of the network.
- If `filter_multiplier` < 1.0, proportionally decreases the number
of filters in each layer.
- If `filter_multiplier` > 1.0, proportionally increases the number
of filters in each layer.
- If `filter_multiplier` = 1, default number of filters from the
paper are used at each layer.
include_top: Whether to include the fully-connected
layer at the top of the network.
weights: `None` (random initialization) or
`imagenet` (ImageNet weights)
input_tensor: Optional Keras tensor (i.e. output of
`layers.Input()`)
to use as image input for the model.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model
will be the 4D tensor output of the
last convolutional layer.
- `avg` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a
2D tensor.
- `max` means that global max pooling will
be applied.
classes: Optional number of classes to classify images
into, only to be specified if `include_top` is True, and
if no `weights` argument is specified.
default_size: Specifies the default image size of the model
# Returns
A Keras model instance.
# Raises
ValueError: In case of invalid argument for `weights`,
invalid input shape or invalid `penultimate_filters` value.
'''
# global backend, layers, models, keras_utils
# backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs)
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError(
'If using `weights` as `"imagenet"` with `include_top` '
'as true, `classes` should be 1000')
if (isinstance(input_shape, tuple) and None in input_shape
and weights == 'imagenet'):
raise ValueError('When specifying the input shape of a NASNet'
' and loading `ImageNet` weights, '
'the input_shape argument must be static '
'(no None entries). Got: `input_shape=' +
str(input_shape) + '`.')
if default_size is None:
default_size = 331
# Determine proper input shape and default size.
input_shape = _obtain_input_shape(input_shape,
default_size=default_size,
min_size=32,
data_format=backend.image_data_format(),
require_flatten=include_top,
weights=weights)
if backend.image_data_format() != 'channels_last':
warnings.warn('The NASNet family of models is only available '
'for the input data format "channels_last" '
'(width, height, channels). '
'However your settings specify the default '
'data format "channels_first" (channels, width, height).'
' You should set `image_data_format="channels_last"` '
'in your Keras config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "channels_last" data format.')
backend.set_image_data_format('channels_last')
old_data_format = 'channels_first'
else:
old_data_format = None
if input_tensor is None:
img_input = layers.Input(shape=input_shape)
else:
if not backend.is_keras_tensor(input_tensor):
img_input = layers.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
if penultimate_filters % 24 != 0:
raise ValueError(
'For NASNet-A models, the value of `penultimate_filters` '
'needs to be divisible by 24. Current value: %d' %
penultimate_filters)
channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1
filters = penultimate_filters // 24
x = layers.Conv2D(stem_block_filters, (3, 3),
strides=(2, 2),
padding='same',
use_bias=False,
kernel_regularizer=l2(weight_decay),
name='stem_conv1',
kernel_initializer='he_normal')(img_input)
if use_bn:
x = layers.BatchNormalization(axis=channel_dim,
momentum=bn_momentum,
epsilon=1e-3,
name='stem_bn1')(x)
x = layers.SpatialDropout2D(drop_p)(x)
x = csSE_block(x, 'res_2x')
p = None
x, p = _reduction_a_cell(x,
p,
filters // (filter_multiplier**2),
block_id='stem_1')
x = csSE_block(x, 'res_4x')
x, p = _reduction_a_cell(x,
p,
filters // filter_multiplier,
block_id='stem_2')
for i in range(num_blocks):
x, p = _normal_a_cell(x, p, filters, block_id='%d' % (i))
x = csSE_block(x, 'res_8x')
x, p0 = _reduction_a_cell(x,
p,
filters * filter_multiplier,
block_id='reduce_%d' % (num_blocks))
p = p0 if not skip_reduction else p
for i in range(num_blocks):
x, p = _normal_a_cell(x,
p,
filters * filter_multiplier,
block_id='%d' % (num_blocks + i + 1))
x = csSE_block(x, 'res_16x')
x, p0 = _reduction_a_cell(x,
p,
filters * filter_multiplier**2,
block_id='reduce_%d' % (2 * num_blocks))
p = p0 if not skip_reduction else p
for i in range(num_blocks):
x, p = _normal_a_cell(x,
p,
filters * filter_multiplier**2,
block_id='%d' % (2 * num_blocks + i + 1))
x = csSE_block(x, 'res_32x')
x = layers.Activation('relu')(x)
if include_top:
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = layers.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = layers.GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = keras_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
model = models.Model(inputs, x, name='NASNet')
# Load weights.
if weights == 'imagenet':
if default_size == 224: # mobile version
if include_top:
weights_path = keras_utils.get_file(
'nasnet_mobile.h5',
NASNET_MOBILE_WEIGHT_PATH,
cache_subdir='models',
file_hash='020fb642bf7360b370c678b08e0adf61')
else:
weights_path = keras_utils.get_file(
'nasnet_mobile_no_top.h5',
NASNET_MOBILE_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='1ed92395b5b598bdda52abe5c0dbfd63')
model.load_weights(weights_path, by_name=True, skip_mismatch=True)
elif default_size == 331: # large version
if include_top:
weights_path = keras_utils.get_file(
'nasnet_large.h5',
NASNET_LARGE_WEIGHT_PATH,
cache_subdir='models',
file_hash='11577c9a518f0070763c2b964a382f17')
else:
weights_path = keras_utils.get_file(
'nasnet_large_no_top.h5',
NASNET_LARGE_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='d81d89dc07e6e56530c4e77faddd61b5')
model.load_weights(weights_path, by_name=True, skip_mismatch=True)
else:
raise ValueError(
'ImageNet weights can only be loaded with NASNetLarge'
' or NASNetMobile')
elif weights is not None:
model.load_weights(weights, by_name=True, skip_mismatch=True)
if old_data_format:
backend.set_image_data_format(old_data_format)
return model
def D3GenerateModel(n_filter=16,
number_of_class=1,
input_shape=(16, 144, 144, 1),
activation_last='sigmoid',
metrics=[
'mse', 'acc', dice_coef, recall_at_thresholds,
precision_at_thresholds, auc_roc
],
loss='binary_crossentropy',
dropout=0.05,
init='glorot_uniform',
two_output=False):
filter_size = n_filter
input_x = layers.Input(shape=input_shape,
name='Input_layer',
dtype='float32')
#1 level
x = layers.Conv3D(filters=filter_size * 2,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
padding='same')(input_x)
x = layers.LeakyReLU()(x)
x = layers.Conv3D(filters=filter_size * 4,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling3D(pool_size=(2, 2, 2), padding='same')(x)
#2 level
conv_list = []
counter = 0
for index, kernel_sizes in enumerate([[(1, 3, 3), (1, 1, 3)],
[(3, 3, 3), (3, 1, 3)],
[(3, 3, 1), (1, 3, 1)]]):
for kernel_size in (kernel_sizes):
x = layers.Conv3D(filters=(filter_size * 8),
kernel_size=kernel_size,
strides=(1, 1, 1),
padding='same',
name='Conv3D_%s' % (counter))(x)
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.SpatialDropout3D(dropout)(x)
counter = counter + 1
conv_list.append(x)
x = layers.add(conv_list)
x = layers.Conv3D(filters=filter_size * 8,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
padding='same')(x)
x = layers.Reshape(target_shape=[4, -1, filter_size * 8])(x)
x = layers.Conv2D(filters=128, kernel_size=(1, 1296), strides=(1, 1296))(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
x = layers.SpatialDropout2D(dropout)(x)
#x = layers.Lambda(squash)(x)
#x = layers.Softmax()(x)
x = layers.Reshape(target_shape=[128, -1])(x)
x = layers.Conv1D(filters=2,
kernel_size=128,
strides=128,
activation='sigmoid')(x)
y = layers.Flatten()(x)
#Classification
model = Model(inputs=input_x, outputs=y)
#keras.optimizers.SGD(lr=lr, momentum=0.90, decay=decay, nesterov=False)
opt_noise = add_gradient_noise(optimizers.Adam)
optimizer = opt_noise(
lr, amsgrad=True) #, nesterov=True)#opt_noise(lr, amsgrad=True)
model.compile(optimizer=optimizer, loss=loss,
metrics=metrics) #categorical_crossentropy
return model
def __init__(self, filters_size, dropout_rate):
self._convo_block = ConvoBlock(filters_size)
self._max_pool = layers.MaxPooling2D((2, 2))
self._dropout = layers.SpatialDropout2D(rate=dropout_rate)
