def conv_vae(batch_input_shape,
latent_dim=2,
intermediate_dim=128,
nb_filters=32,
nb_conv=3,
epsilon_std=0.01):
batch_size, img_chns, img_rows, img_cols = batch_input_shape
# Input
x = Input(batch_shape=batch_input_shape)
# Encoder
c = Convolution2D(nb_filters,
nb_conv,
nb_conv,
border_mode='same',
activation='relu')(x)
f = Flatten()(c)
# Sampling
h = Dense(intermediate_dim, activation='relu')(f)
z_mean = Dense(latent_dim)(h)
z_log_var = Dense(latent_dim)(h)
def sampling(args):
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(batch_size, latent_dim),
mean=0.,
std=epsilon_std)
return z_mean + K.exp(z_log_var) * epsilon
z = Lambda(sampling, output_shape=(latent_dim, ))([z_mean, z_log_var])
# Decoder
decoder_h = Dense(intermediate_dim, activation='relu')
decoder_f = Dense(nb_filters * img_rows * img_cols, activation='relu')
decoder_c = Reshape((nb_filters, img_rows, img_cols))
decoder_mean = Deconvolution2D(img_chns,
nb_conv,
nb_conv,
(batch_size, img_chns, img_rows, img_cols),
border_mode='same')
h_decoded = decoder_h(z)
f_decoded = decoder_f(h_decoded)
c_decoded = decoder_c(f_decoded)
x_decoded_mean = decoder_mean(c_decoded)
# Define loss
def vae_loss(x, x_decoded_mean):
# NOTE: binary_crossentropy expects a batch_size by dim for x and x_decoded_mean, so we MUST flatten these!
x = K.flatten(x)
x_decoded_mean = K.flatten(x_decoded_mean)
xent_loss = objectives.mean_squared_error(x, x_decoded_mean)
kl_loss = -0.5 * K.mean(
1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
return xent_loss + kl_loss
# Compile Model
vae = Model(x, x_decoded_mean)
vae.compile(optimizer='rmsprop', loss=vae_loss)
vae.summary()
# build a model to project inputs on the latent space
encoder = Model(x, z_mean)
return vae, encoder
epsilon = K.random_normal(shape=(batch_size, latent_dim),
mean=0.,
stddev=epsilon_std)
return z_mean + K.exp(z_log_var) * epsilon
z = Lambda(sampling, output_shape=(latent_dim, ),
name='sample_layer')([z_mean, z_log_var])
dec = Dense(intermediate_dim, name='dec_hid')(z)
dec = Dense(8 * 8 * 256, activation='relu', name='fc_latent_in')(dec)
dec = BatchNormalization(name='debatch_1')(dec)
dec = Activation('relu')(dec)
dec = Reshape((8, 8, 256), name='reshape')(dec)
dec = Deconvolution2D(256, (5, 5),
strides=(2, 2),
padding='same',
name='deconv_1')(dec)
dec = BatchNormalization(name='debatch_2')(dec)
dec = Activation('relu')(dec)
dec = Deconvolution2D(128, (5, 5),
strides=(2, 2),
padding='same',
activation='relu',
name='deconv_2')(dec)
dec = BatchNormalization(name='debatch_3')(dec)
dec = Activation('relu')(dec)
dec = Deconvolution2D(32, (5, 5),
strides=(2, 2),
padding='same',
activation='relu',
name='deconv_3')(dec)
model.add(
Convolution2D(nb_filters,
kernal_size[0],
kernal_size[1],
border_mode='valid',
input_shape=input_shape))
# 3x3 convolution on top, with 16 output filters
model.add(Convolution2D(8, kernal_size[0], kernal_size[1],
border_mode='valid'))
# 3x3 transposed convolution with 32 output filters and stride 1x1 on a 16 24x24 images
model.add(
Deconvolution2D(32,
kernal_size[0],
kernal_size[1],
output_shape=(None, 32, 22, 22),
border_mode='valid',
input_shape=(8, 16, 16)))
# 3x3 transposed convolution with 1 output filter and stride 1x1 on a 32 26x26 images
model.add(
Deconvolution2D(1,
kernal_size[0],
kernal_size[1],
output_shape=(None, 1, 28, 28),
border_mode='valid',
input_shape=(32, 22, 22)))
model.summary()
'''
Compile and fit
def DeepCapsNet(input_shape, n_class, routings):
# assemble encoder
x = Input(shape=input_shape)
l = x
l = Conv2D(128, (3, 3), strides=(1, 1), activation='relu',
padding="same")(l) # common conv layer
l = BatchNormalization()(l)
l = ConvertToCaps()(l)
l = Conv2DCaps(32,
4,
kernel_size=(3, 3),
strides=(2, 2),
r_num=1,
b_alphas=[1, 1, 1])(l)
l_skip = Conv2DCaps(32,
4,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
4,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
4,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = layers.Add()([l, l_skip])
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(2, 2),
r_num=1,
b_alphas=[1, 1, 1])(l)
l_skip = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = layers.Add()([l, l_skip])
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(2, 2),
r_num=1,
b_alphas=[1, 1, 1])(l)
l_skip = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = layers.Add()([l, l_skip])
l1 = l
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(2, 2),
r_num=1,
b_alphas=[1, 1, 1])(l)
l_skip = ConvCapsuleLayer3D(kernel_size=3,
num_capsule=32,
num_atoms=8,
strides=1,
padding='same',
routings=3)(l)
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = Conv2DCaps(32,
8,
kernel_size=(3, 3),
strides=(1, 1),
r_num=1,
b_alphas=[1, 1, 1])(l)
l = layers.Add()([l, l_skip])
l2 = l
la = FlattenCaps()(l2)
lb = FlattenCaps()(l1)
l = layers.Concatenate(axis=-2)([la, lb])
# l = Dropout(0.4)(l)
digits_caps = CapsuleLayer(num_capsule=n_class,
dim_capsule=32,
routings=routings,
channels=0,
name='digit_caps')(l)
l = CapsToScalars(name='capsnet')(digits_caps)
m_capsnet = models.Model(inputs=x, outputs=l, name='capsnet_model')
y = Input(shape=(n_class, ))
masked_by_y = Mask_CID()([digits_caps, y])
masked = Mask_CID()(digits_caps)
# Decoder Network
decoder = models.Sequential(name='decoder')
decoder.add(Dense(input_dim=32, activation="relu", output_dim=8 * 8 * 16))
decoder.add(Reshape((8, 8, 16)))
decoder.add(BatchNormalization(momentum=0.8))
decoder.add(Deconvolution2D(64, 3, 3, subsample=(1, 1),
border_mode='same'))
decoder.add(Deconvolution2D(32, 3, 3, subsample=(2, 2),
border_mode='same'))
decoder.add(Deconvolution2D(16, 3, 3, subsample=(2, 2),
border_mode='same'))
decoder.add(Deconvolution2D(8, 3, 3, subsample=(2, 2), border_mode='same'))
decoder.add(Deconvolution2D(3, 3, 3, subsample=(1, 1), border_mode='same'))
decoder.add(Activation("relu"))
decoder.add(Reshape(target_shape=(64, 64, 3), name='out_recon'))
train_model = models.Model(
[x, y], [m_capsnet.output, decoder(masked_by_y)])
eval_model = models.Model(x, [m_capsnet.output, decoder(masked)])
train_model.summary()
return train_model, eval_model
z = Lambda(sampling, output_shape=(latent_dim, ))([z_mean, z_log_var])
# we instantiate these layers separately so as to reuse them later
decoder_hid = Dense(intermediate_dim, activation='relu')
decoder_upsample = Dense(nb_filters * 14 * 14, activation='relu')
if K.image_dim_ordering() == 'th':
output_shape = (batch_size, nb_filters, 14, 14)
else:
output_shape = (batch_size, 14, 14, nb_filters)
decoder_reshape = Reshape(output_shape[1:])
decoder_deconv_1 = Deconvolution2D(nb_filters,
nb_conv,
nb_conv,
output_shape,
border_mode='same',
subsample=(1, 1),
activation='relu')
decoder_deconv_2 = Deconvolution2D(nb_filters,
nb_conv,
nb_conv,
output_shape,
border_mode='same',
subsample=(1, 1),
activation='relu')
if K.image_dim_ordering() == 'th':
output_shape = (batch_size, nb_filters, 29, 29)
else:
output_shape = (batch_size, 29, 29, nb_filters)
decoder_deconv_3_upsamp = Deconvolution2D(nb_filters,
mean=0.,
std=epsilon_std)
return z_mean + K.exp(z_log_var) * epsilon
# note that "output_shape" isn't necessary with the TensorFlow backend
# so you could write `Lambda(sampling)([z_mean, z_log_var])`
z = Lambda(sampling, output_shape=(latent_dim, ))([z_mean, z_log_var])
# we instantiate these layers separately so as to reuse them later
decoder_h = Dense(intermediate_dim, activation='relu')
decoder_f = Dense(nb_filters * img_rows * img_cols, activation='relu')
decoder_c = Reshape((nb_filters, img_rows, img_cols))
decoder_mean = Deconvolution2D(img_chns,
nb_conv,
nb_conv,
(batch_size, img_chns, img_rows, img_cols),
border_mode='same')
h_decoded = decoder_h(z)
f_decoded = decoder_f(h_decoded)
c_decoded = decoder_c(f_decoded)
x_decoded_mean = decoder_mean(c_decoded)
def vae_loss(x, x_decoded_mean):
# NOTE: binary_crossentropy expects a batch_size by dim for x and x_decoded_mean, so we MUST flatten these!
x = K.flatten(x)
x_decoded_mean = K.flatten(x_decoded_mean)
xent_loss = objectives.binary_crossentropy(x, x_decoded_mean)
kl_loss = -0.5 * K.mean(
def fcn_32s_to_8s(fcn32model=None):
if (fcn32model is None):
fcn32model = fcn32_blank()
fcn32shape = fcn32model.layers[-1].output_shape
assert (len(fcn32shape) == 4)
assert (fcn32shape[0] is None) # batch axis
assert (fcn32shape[3] == 21) # number of filters
assert (fcn32shape[1] == fcn32shape[2]) # must be square
fcn32size = fcn32shape[1] # INFO: =32 when images are 512x512
if (fcn32size != 32):
print(
'WARNING : handling of image size different from 512x512 has not been tested'
)
sp4 = Convolution2D(21,
kernel_size=(1, 1),
padding='same',
activation=None,
name='score_pool4')
# INFO : to replicate MatConvNet.DAGN.Sum layer see documentation at :
# https://keras.io/getting-started/sequential-model-guide/
summed = add(inputs=[
sp4(fcn32model.layers[14].output), fcn32model.layers[-1].output
])
deconv4_output_size = (fcn32size -
1) * 2 + 4 # INFO: =66 when images are 512x512
s4deconv = Deconvolution2D(
21,
kernel_size=(4, 4),
#output_shape=(None, 21, deconv4_output_size, deconv4_output_size),
padding='valid', # WARNING : valid, same or full ?
strides=(2, 2),
activation=None,
name='score4')
extra_margin4 = deconv4_output_size - fcn32size * 2 # INFO: =2 when images are 512x512
assert (extra_margin4 > 0)
assert (extra_margin4 % 2 == 0)
crop_margin4 = Cropping2D(
cropping=((0, extra_margin4),
(0,
extra_margin4))) # INFO : cropping as deconv gained pixels
score4 = crop_margin4(s4deconv(summed))
# WARNING : check dimensions
sp3 = Convolution2D(
21,
kernel_size=(1, 1),
padding='same', # WARNING : zero or same ? does not matter for 1x1
activation=None, # WARNING : to check
name='score_pool3')
score_final = add(inputs=[sp3(fcn32model.layers[10].output),
score4]) # WARNING : is that correct ?
assert (fcn32size * 2 == fcn32model.layers[10].output_shape[1])
deconvUP_output_size = (fcn32size * 2 -
1) * 8 + 16 # INFO: =520 when images are 512x512
upsample = Deconvolution2D(
21,
kernel_size=(16, 16),
#output_shape=(None, 21, deconvUP_output_size, deconvUP_output_size),
padding='valid', # WARNING : valid, same or full ?
strides=(8, 8),
activation=None,
name='upsample')
bigscore = upsample(score_final)
extra_marginUP = deconvUP_output_size - (
fcn32size * 2) * 8 # INFO: =8 when images are 512x512
assert (extra_marginUP > 0)
assert (extra_marginUP % 2 == 0)
crop_marginUP = Cropping2D(
cropping=((0, extra_marginUP),
(0,
extra_marginUP))) # INFO : cropping as deconv gained pixels
coarse = crop_marginUP(bigscore)
return Model(fcn32model.input, coarse)
decoder_model.add(Convolution2D(64, 3, 3, subsample = (1,1), border_mode='same',
input_shape=intermediate_layer_output.shape[1:]))
decoder_model.add(Activation('relu'))
decoder_model.add(Convolution2D(64, 3, 3, subsample = (1,1), border_mode='same'))
decoder_model.add(Activation('relu'))
decoder_model.add(Convolution2D(64, 3, 3, subsample = (1,1), border_mode='same'))
decoder_model.add(Activation('relu'))
# decoder_model.add(ZeroPadding2D(padding=(1,1)))
#decoder_model.add(Deconvolution2D(64, 5, 5, output_shape=(None, 64, 8, 8), subsample = (2,2), border_mode = 'same'))
#decoder_model.add(Activation('relu'))
#decoder_model.add(Deconvolution2D(32, 5, 5,output_shape=(None, 32, 16, 16), subsample = (2,2), border_mode = 'same'))
#decoder_model.add(Activation('relu'))
decoder_model.add(Deconvolution2D(3, 5, 5,output_shape=(None, 3, 32, 32), subsample = (2,2), border_mode = 'same'))
decoder_model.add(Activation('relu'))
#decoder_model.add(Deconvolution2D(8, 5, 5,output_shape=(None, 8, 96, 96), subsample = (2,2), border_mode = 'same'))
#decoder_model.add(Activation('relu'))
#decoder_model.add(Deconvolution2D(3, 5, 5, output_shape=(None, 3, 32,32), subsample = (2,2), border_mode = 'same'))
#decoder_model.add(Activation('relu'))
#decoder_model.add(Deconvolution2D(256, 5, 5,output_shape=(None, 3, 25, 25), subsample = (2,2), border_mode = 'same'))
# let's train the model using SGD + momentum (how original).
#sgd = SGD(lr = 0.1, decay = 1e-6, momentum = 0.9, nesterov = True)
rms= RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
decoder_model.compile(loss = 'mean_squared_error',
optimizer = rms,metrics = ['mean_absolute_percentage_error'])
#print decoder_model.layers[-1].output_shape
def activationModel(model):
# grab the conv layers
current_stack = []
act_stack = []
for layer in model.layers:
if layer.name.startswith("conv"):
current_stack.insert(0, layer)
#print('*********8')
#print(layer.outbound_nodes[0].outbound_layer.name)
nextlayer = layer.outbound_nodes[0].outbound_layer
#print(nextlayer.name)
if (nextlayer.name.startswith("elu")):
act_stack.insert(0, nextlayer)
elif (nextlayer.name.startswith("activ")):
act_stack.insert(0, nextlayer)
else:
act_stack.insert(0, layer)
print("current stack:")
for layer in current_stack:
print(layer.name)
print(layer.outbound_nodes[0].outbound_layer.name)
print("act stack:")
for layer in act_stack:
print(layer.name)
print("---------")
lastone = None
# hold onto last one..
for i, layer in enumerate(current_stack):
#print(layer.name,i)
our_shape = (layer.output_shape[1], layer.output_shape[2], 1)
hidden_layer = act_stack[i]
#print(hidden_layer.name)
#print(layer.name)
#print(our_shape)
# average this layer
name = 'lambda_new_' + str(i)
c1 = Lambda(lambda xin: K.mean(xin, axis=3),
name=name)(hidden_layer.output)
name = 'reshape_new_' + str(i)
r1 = Reshape(our_shape, name=name)(c1)
#lastone=r1
if (i != 0):
# if we aren't the bottom, multiply by output of layer below
print("multiply")
name = 'multiply_' + str(i)
r1 = merge([r1, lastone], mode='mul', name=name)
lastone = r1
if (i < len(current_stack) - 1):
print('do deconv')
# deconv to the next bigger size
bigger_shape = current_stack[i + 1].output_shape
else:
bigger_shape = model.input_shape
bigger_shape = (bigger_shape[0], bigger_shape[1], bigger_shape[2], 1)
if (LooseVersion(keras.__version__) > LooseVersion("2.0.0")):
print("Keras 2")
subsample = current_stack[i].strides
nb_row, nb_col = current_stack[i].kernel_size
else:
subsample = current_stack[i].subsample
nb_row = current_stack[i].nb_row
nb_col = current_stack[i].nb_col
#print("deconv params:")
#print("subsample:",subsample)
#nb_row,nb_col=current_stack[i].kernel_size
#print("nb_col,nb_row:",nb_col,nb_row)
#print("bigger_shape:",bigger_shape)
name = 'deconv_new_' + str(i)
print(name)
print('Deconvolution2D(1,', nb_row, nb_col, 'output_shape=',
bigger_shape, 'subsample= ', subsample, 'border_mode=valid',
'activation=relu', 'init=one', 'name=', name)
d1 = Deconvolution2D(1,
nb_row,
nb_col,
output_shape=bigger_shape,
subsample=subsample,
border_mode='valid',
activation='relu',
init='one',
name=name)(r1)
if (d1._keras_shape[1] != bigger_shape[1]
or d1._keras_shape[2] != bigger_shape[2]):
print("d1:", d1._keras_shape)
pad = 0
if (d1._keras_shape[1] < bigger_shape[1]):
if (d1._keras_shape[2] != bigger_shape[2]):
pad = 1
else:
pad = 0
z1 = ZeroPadding2D(padding=(1, pad), data_format=None)(d1)
c1 = Cropping2D(cropping=((1, 0), (pad, 0)),
data_format=None)(z1)
print("z1:", z1._keras_shape)
else:
print("making smaller")
padx = d1._keras_shape[1] - bigger_shape[1]
pady = d1._keras_shape[2] - bigger_shape[2]
print("padx,pady", padx, pady)
c1 = Cropping2D(cropping=((padx, 0), (pady, 0)),
data_format=None)(d1)
print("c1:", c1._keras_shape)
lastone = c1
else:
lastone = d1
model2 = Model(input=model.input, output=[lastone])
model2.summary()
return model2
z_mean, z_log_var = args
epsilon = K.random_normal(shape=(batch_size, latent_dim),
mean=0., std=epsilon_std)
return z_mean + K.exp(z_log_var) * epsilon
# note that "output_shape" isn't necessary with the TensorFlow backend
# so you could write `Lambda(sampling)([z_mean, z_log_var])`
z = Lambda(sampling, output_shape=(latent_dim,))([z_mean, z_log_var])
# we instantiate these layers separately so as to reuse them later
decoder_hid = Dense(intermediate_dim, activation='relu')
decoder_upsample = Dense(nb_filters * 14 * 14, activation='relu')
decoder_reshape = Reshape((nb_filters, 14, 14))
decoder_deconv_1 = Deconvolution2D(nb_filters, nb_conv, nb_conv,
(batch_size, nb_filters, 14, 14),
border_mode='same',
subsample=(1, 1),
activation='relu')
decoder_deconv_2 = Deconvolution2D(nb_filters, nb_conv, nb_conv,
(batch_size, nb_filters, 14, 14),
border_mode='same',
subsample=(1, 1),
activation='relu')
decoder_deconv_3_upsamp = Deconvolution2D(nb_filters, 2, 2,
(batch_size, nb_filters, 29, 29),
border_mode='valid',
subsample=(2, 2),
activation='relu')
decoder_mean_squash = Convolution2D(img_chns, 2, 2, border_mode='valid', activation='sigmoid')
hid_decoded = decoder_hid(z)
def add_context(model, no_of_classes):
model.add(
Conv2D(no_of_classes * 2, (3, 3),
padding="same",
activation='relu',
name="ct_conv1_1"))
model.add(
Conv2D(no_of_classes * 2, (3, 3),
padding="same",
activation='relu',
name="ct_conv1_2"))
model.add(
Conv2D(no_of_classes * 4, (3, 3),
padding="same",
dilation_rate=(2, 2),
activation='relu',
name="ct_conv2_1"))
model.add(
Conv2D(no_of_classes * 8, (3, 3),
padding="same",
dilation_rate=(4, 4),
activation='relu',
name="ct_conv3_1"))
model.add(
Conv2D(no_of_classes * 16, (3, 3),
padding='same',
dilation_rate=(8, 8),
activation='relu',
name="ct_conv4_1"))
model.add(
Conv2D(no_of_classes * 32, (3, 3),
padding='same',
dilation_rate=(16, 16),
activation='relu',
name="ct_conv5_1"))
model.add(
Conv2D(no_of_classes * 32, (3, 3),
padding='same',
activation='relu',
name="ct_fc1"))
model.add(
Deconvolution2D(no_of_classes,
kernel_size=(3, 3),
strides=(2, 2),
activation="relu",
name="ct_deconv_1",
padding="same"))
model.add(
Deconvolution2D(no_of_classes,
kernel_size=(3, 3),
strides=(2, 2),
activation="relu",
name="ct_deconv_2",
padding="same"))
model.add(
Deconvolution2D(no_of_classes,
kernel_size=(3, 3),
strides=(2, 2),
activation="relu",
name="ct_deconv_3",
padding="same"))
model.add(Conv2D(no_of_classes, (1, 1), activation='relu',
name="ct_final"))
return model
def SSD(input_shape, num_classes=21):
"""SSD300 architecture.
# Arguments
input_shape: Shape of the input image,
expected to be either (300, 300, 3) or (3, 300, 300)(not tested).
num_classes: Number of classes including background.
# References
https://arxiv.org/abs/1512.02325
"""
# net = {}
# Block 1
input_tensor = Input(shape=input_shape)
img_size = (input_shape[1], input_shape[0])
input_img = input_tensor
conv1_1 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='conv1_1')(input_img)
conv1_2 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='conv1_2')(conv1_1)
pool1 = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
name='pool1')(conv1_2)
# Block 2
conv2_1 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='conv2_1')(pool1)
conv2_2 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='conv2_2')(conv2_1)
pool2 = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
name='pool2')(conv2_2)
# Block 3
conv3_1 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='conv3_1')(pool2)
conv3_2 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='conv3_2')(conv3_1)
conv3_3 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='conv3_3')(conv3_2)
pool3 = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
name='pool3')(conv3_3)
# Block 4
conv4_1 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='conv4_1')(pool3)
conv4_2 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='conv4_2')(conv4_1)
conv4_3 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='conv4_3')(conv4_2)
pool4 = MaxPooling2D((2, 2), strides=(2, 2), padding='same',
name='pool4')(conv4_3)
# Block 5
conv5_1 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='conv5_1')(pool4)
conv5_2 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='conv5_2')(conv5_1)
conv5_3 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='conv5_3')(conv5_2)
pool5 = MaxPooling2D((3, 3), strides=(1, 1), padding='same',
name='pool5')(conv5_3)
# FC6
fc6 = Conv2D(1024, (3, 3),
dilation_rate=(6, 6),
activation='relu',
padding='same',
name='fc6')(pool5)
#fc6 = Dropout(0.5, name='drop6')(fc6)
# FC7
fc7 = Conv2D(1024, (1, 1), padding='same', activation='relu',
name='fc7')(fc6)
#fc7 = Dropout(0.5, name='drop7')(fc7)
# Block 6
conv6_1 = Conv2D(256, (1, 1),
activation='relu',
padding='same',
name='conv6_1')(fc7)
conv6_2 = Conv2D(512, (3, 3),
strides=(2, 2),
activation='relu',
padding='same',
name='conv6_2')(conv6_1)
# Block 7
conv7_1 = Conv2D(128, (1, 1),
activation='relu',
padding='same',
name='conv7_1')(conv6_2)
conv7_2 = ZeroPadding2D()(conv7_1)
conv7_2 = Conv2D(256, (3, 3),
strides=(2, 2),
activation='relu',
padding='valid',
name='conv7_2')(conv7_2)
# Block 8
conv8_1 = Conv2D(128, (1, 1),
activation='relu',
padding='same',
name='conv8_1')(conv7_2)
conv8_2 = Conv2D(256, (3, 3),
strides=(2, 2),
activation='relu',
padding='same',
name='conv8_2')(conv8_1)
# Last Pool
pool6 = GlobalAveragePooling2D(name='pool6')(conv8_2)
# Prediction from conv4_3
conv4 = Conv2D(512, (3, 3), padding='same', name='conv4')(conv4_3)
conv4_3_norm = Normalize(num_classes - 1, name='conv4_3_norm')(conv4)
deconv5_3 = Deconvolution2D(512, (3, 3),
strides=(2, 2),
padding='same',
name='deconv5_3')(conv5_3)
conv_deconv5_3 = Conv2D(512, (3, 3), padding='same',
name='conv_deconv5_3')(deconv5_3)
conv5_3_norm = Normalize((num_classes - 1) / 2,
name='conv_5_3_norm')(conv_deconv5_3)
EltSUM = add([conv4_3_norm, conv5_3_norm])
fusion_conv4_5 = Activation(name='fusion_conv4_5',
activation='relu')(EltSUM)
num_priors = 3
fusion_conv4_5_mbox_loc = Conv2D(
num_priors * 4, (3, 3), padding='same',
name='fusion_conv4_5_mbox_loc')(fusion_conv4_5)
fusion_conv4_5_mbox_loc_flat = Flatten(
name='fusion_conv4_5_mbox_loc_flat')(fusion_conv4_5_mbox_loc)
name = 'fusion_conv4_5_mbox_conf'
if num_classes != 21:
name += '_{}'.format(num_classes)
fusion_conv4_5_mbox_conf = Conv2D(num_priors * num_classes, (3, 3),
padding='same',
name=name)(fusion_conv4_5)
fusion_conv4_5_mbox_conf_flat = Flatten(
name='fusion_conv4_5_mbox_conf_flat')(fusion_conv4_5_mbox_conf)
fusion_conv4_5_mbox_priorbox = PriorBox(
img_size,
30.0,
aspect_ratios=[2],
variances=[0.1, 0.1, 0.2, 0.2],
name='fusion_conv4_5_mbox_priorbox')(fusion_conv4_5)
# Prediction from fc7
num_priors = 6
fc7_mbox_loc = Conv2D(num_priors * 4, (3, 3),
padding='same',
name='fc7_mbox_loc')(fc7)
fc7_mbox_loc_flat = Flatten(name='fc7_mbox_loc_flat')(fc7_mbox_loc)
name = 'fc7_mbox_conf'
if num_classes != 21:
name += '_{}'.format(num_classes)
fc7_mbox_conf = Conv2D(num_priors * num_classes, (3, 3),
padding='same',
name=name)(fc7)
fc7_mbox_conf_flat = Flatten(name='fc7_mbox_conf_flat')(fc7_mbox_conf)
fc7_mbox_priorbox = PriorBox(img_size,
60.0,
max_size=114.0,
aspect_ratios=[2, 3],
variances=[0.1, 0.1, 0.2, 0.2],
name='fc7_mbox_priorbox')(fc7)
# Prediction from conv6_2
num_priors = 6
conv6_2_mbox_loc = Conv2D(num_priors * 4, (3, 3),
padding='same',
name='conv6_2_mbox_loc')(conv6_2)
conv6_2_mbox_loc_flat = Flatten(
name='conv6_2_mbox_loc_flat')(conv6_2_mbox_loc)
name = 'conv6_2_mbox_conf'
if num_classes != 21:
name += '_{}'.format(num_classes)
conv6_2_mbox_conf = Conv2D(num_priors * num_classes, (3, 3),
padding='same',
name=name)(conv6_2)
conv6_2_mbox_conf_flat = Flatten(
name='conv6_2_mbox_conf_flat')(conv6_2_mbox_conf)
conv6_2_mbox_priorbox = PriorBox(img_size,
114.0,
max_size=168.0,
aspect_ratios=[2, 3],
variances=[0.1, 0.1, 0.2, 0.2],
name='conv6_2_mbox_priorbox')(conv6_2)
# Prediction from conv7_2
num_priors = 6
conv7_2_mbox_loc = Conv2D(num_priors * 4, (3, 3),
padding='same',
name='conv7_2_mbox_loc')(conv7_2)
conv7_2_mbox_loc_flat = Flatten(
name='conv7_2_mbox_loc_flat')(conv7_2_mbox_loc)
name = 'conv7_2_mbox_conf'
if num_classes != 21:
name += '_{}'.format(num_classes)
conv7_2_mbox_conf = Conv2D(num_priors * num_classes, (3, 3),
padding='same',
name=name)(conv7_2)
conv7_2_mbox_conf_flat = Flatten(
name='conv7_2_mbox_conf_flat')(conv7_2_mbox_conf)
conv7_2_mbox_priorbox = PriorBox(img_size,
168.0,
max_size=222.0,
aspect_ratios=[2, 3],
variances=[0.1, 0.1, 0.2, 0.2],
name='conv7_2_mbox_priorbox')(conv7_2)
# Prediction from conv8_2
num_priors = 6
conv8_2_mbox_loc = Conv2D(num_priors * 4, (3, 3),
padding='same',
name='conv8_2_mbox_loc')(conv8_2)
conv8_2_mbox_loc_flat = Flatten(
name='conv8_2_mbox_loc_flat')(conv8_2_mbox_loc)
name = 'conv8_2_mbox_conf'
if num_classes != 21:
name += '_{}'.format(num_classes)
conv8_2_mbox_conf = Conv2D(num_priors * num_classes, (3, 3),
padding='same',
name=name)(conv8_2)
conv8_2_mbox_conf_flat = Flatten(
name='conv8_2_mbox_conf_flat')(conv8_2_mbox_conf)
conv8_2_mbox_priorbox = PriorBox(img_size,
222.0,
max_size=276.0,
aspect_ratios=[2, 3],
variances=[0.1, 0.1, 0.2, 0.2],
name='conv8_2_mbox_priorbox')(conv8_2)
# Prediction from pool6
num_priors = 6
pool6_mbox_loc_flat = Dense(num_priors * 4,
name='pool6_mbox_loc_flat')(pool6)
name = 'pool6_mbox_conf_flat'
if num_classes != 21:
name += '_{}'.format(num_classes)
pool6_mbox_conf_flat = Dense(num_priors * num_classes, name=name)(pool6)
if K.image_dim_ordering() == 'tf':
target_shape = (1, 1, 256)
else:
target_shape = (256, 1, 1)
pool6_reshaped = Reshape(target_shape, name='pool6_reshaped')(pool6)
pool6_mbox_priorbox = PriorBox(img_size,
276.0,
max_size=330.0,
aspect_ratios=[2, 3],
variances=[0.1, 0.1, 0.2, 0.2],
name='pool6_mbox_priorbox')(pool6_reshaped)
# Gather all predictions
mbox_loc = concatenate([
fusion_conv4_5_mbox_loc_flat, fc7_mbox_loc_flat, conv6_2_mbox_loc_flat,
conv7_2_mbox_loc_flat, conv8_2_mbox_loc_flat, pool6_mbox_loc_flat
],
axis=1,
name='mbox_loc')
mbox_conf = concatenate([
fusion_conv4_5_mbox_conf_flat, fc7_mbox_conf_flat,
conv6_2_mbox_conf_flat, conv7_2_mbox_conf_flat, conv8_2_mbox_conf_flat,
pool6_mbox_conf_flat
],
axis=1,
name='mbox_conf')
mbox_priorbox = concatenate([
fusion_conv4_5_mbox_priorbox, fc7_mbox_priorbox, conv6_2_mbox_priorbox,
conv7_2_mbox_priorbox, conv8_2_mbox_priorbox, pool6_mbox_priorbox
],
axis=1,
name='mbox_priorbox')
if hasattr(mbox_loc, '_keras_shape'):
num_boxes = mbox_loc._keras_shape[-1] // 4
elif hasattr(mbox_loc, 'int_shape'):
num_boxes = K.int_shape(mbox_loc)[-1] // 4
mbox_loc = Reshape((num_boxes, 4), name='mbox_loc_final')(mbox_loc)
mbox_conf = Reshape((num_boxes, num_classes),
name='mbox_conf_logits')(mbox_conf)
mbox_conf = Activation('softmax', name='mbox_conf_final')(mbox_conf)
predictions = concatenate([mbox_loc, mbox_conf, mbox_priorbox],
axis=2,
name='predictions')
model = Model(input_img, predictions)
return model
def get_2D_Deeply_supervised_network():
inputs = Input((cm.img_rows, cm.img_cols, 1))
conv1 = Convolution2D(8,
kernel_size=(9, 9),
activation='relu',
border_mode='same')(inputs)
conv1 = Convolution2D(8,
kernel_size=(9, 9),
activation='relu',
border_mode='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
deconv1 = Deconvolution2D(8,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(pool1)
prediction1 = Convolution2D(1, 1, 1, activation='sigmoid')(deconv1)
conv2 = Convolution2D(16,
kernel_size=(7, 7),
activation='relu',
border_mode='same')(pool1)
conv2 = Convolution2D(32,
kernel_size=(7, 7),
activation='relu',
border_mode='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
deconv2 = Deconvolution2D(8,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(pool2)
deconv2 = Deconvolution2D(8,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(deconv2)
prediction2 = Convolution2D(1, 1, 1, activation='sigmoid')(deconv2)
conv3 = Convolution2D(32,
kernel_size=(5, 5),
activation='relu',
border_mode='same')(pool2)
conv3 = Convolution2D(32,
kernel_size=(1, 1),
activation='relu',
border_mode='same')(conv3)
deconv3 = Deconvolution2D(8,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(conv3)
deconv3 = Deconvolution2D(8,
kernel_size=(3, 3),
strides=(2, 2),
padding="same")(deconv3)
prediction3 = Convolution2D(1, 1, 1, activation='sigmoid')(deconv3)
model1 = Model(input=inputs, output=prediction1)
model2 = Model(input=inputs, output=prediction2)
model3 = Model(input=inputs, output=prediction3)
# model.compile(optimizer=Adam(lr=1.0e-5), loss=dice_coef_loss, metrics=[dice_coef])
model1.compile(optimizer=Adam(lr=1.0e-6),
loss=lf.binary_crossentropy_loss,
metrics=[lf.binary_crossentropy])
return model1
def deconv_func(input_layer, pad_mode='same'):
x = Deconvolution2D(32, 4, strides=2, padding=pad_mode)(input_layer)
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
# Conv Layer 6
model.add(Convolution2D(50, 3, 3, border_mode='valid', subsample=(1,1), activation = 'relu', name = 'Conv6'))
model.add(Dropout(0.3))
# Conv Layer 7
model.add(Convolution2D(60, 3, 3, border_mode='valid', subsample=(1,1), activation = 'relu', name = 'Conv7'))
model.add(Dropout(0.3))
# Pooling 3
model.add(MaxPooling2D(pool_size=pool_size))
# Upsample 1
model.add(UpSampling2D(size=pool_size))
# Deconv 1
model.add(Deconvolution2D(50, 3, 3, border_mode='valid', subsample=(1,1), activation = 'relu',
output_shape = model.layers[8].output_shape, name = 'Deconv1'))
model.add(Dropout(0.3))
# Deconv 2
model.add(Deconvolution2D(40, 3, 3, border_mode='valid', subsample=(1,1), activation = 'relu',
output_shape = model.layers[7].output_shape, name = 'Deconv2'))
model.add(Dropout(0.3))
# Upsample 2
model.add(UpSampling2D(size=pool_size))
# Deconv 3
model.add(Deconvolution2D(40, 3, 3, border_mode='valid', subsample=(1,1), activation = 'relu',
output_shape = model.layers[5].output_shape, name = 'Deconv3'))
model.add(Dropout(0.2))
def autoencoder_CNN(input_img):
dropRate = 0.5
#drop_input=Dropout(dropRate)(input_img)
conv1 = Conv2D(128, (3, 3), activation='relu')(input_img) #28 x 28 x 32
#norm1=BatchNormalization()(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) #14 x 14 x 32
#drop1=Dropout(dropRate)(pool1)
conv2 = Conv2D(256, (3, 3), activation='relu')(pool1) #14 x 14 x 64
#norm2=BatchNormalization()(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) #7 x 7 x 64
#drop2=Dropout(dropRate)(pool2)
conv3 = Conv2D(512, (3, 3),
activation='relu')(pool2) #7 x 7 x 128 (small and thick)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) #7 x 7 x 64
# #norm3=BatchNormalization()(conv3)
conv4 = Conv2D(16, (3, 3),
activation='relu')(pool3) #7 x 7 x 128 (small and thick)
# pool4 = MaxPooling2D(pool_size=(2, 2))(conv4) #7 x 7 x 64
# conv5 = Conv2D(2048, (2, 2), activation='relu')(pool4) #7 x 7 x 128 (small and thick)
# pool4 = MaxPooling2D(pool_size=(2, 2))(conv4) #7 x 7 x 64
# #decoder
de_conv1 = Deconvolution2D(512, (3, 3),
activation='relu',
output_shape=(None, 1, 14,
14))(conv4) #7 x 7 x 128
up1 = UpSampling2D((2, 2))(de_conv1)
de_conv2 = Deconvolution2D(256, (3, 3),
activation='relu',
output_shape=(None, 1, 30,
30))(up1) #7 x 7 x 128
up2 = UpSampling2D((2, 2))(de_conv2)
de_conv3 = Deconvolution2D(128, (3, 3),
activation='relu',
output_shape=(None, 1, 62,
62))(up2) #7 x 7 x 128
up3 = UpSampling2D((2, 2))(de_conv3)
de_conv4 = Deconvolution2D(1, (3, 3),
activation='relu',
output_shape=(None, 1, 126,
126))(up3) #7 x 7 x 128
# #norm4=BatchNormalization()(conv4)
# up1 = UpSampling2D((2,2))(conv4) # 14 x 14 x 128
# #drop4=Dropout(dropRate)(up1)
# conv5 = Deconvolution2D(256, (3, 3), activation='relu',output_shape=(None,1,64,64))(up1) # 14 x 14 x 64
# #norm5=BatchNormalization()(conv5)
# up2 = UpSampling2D((4,4))(conv5) # 28 x 28 x 64
# #drop5=Dropout(dropRate)(up2)
#decoded = Deconvolution2D(1, (3, 3), activation='sigmoid',output_shape=(None,1,130,130))(up2) # 28 x 28 x 1
decoded = de_conv4
# CNN classifier
# CNN_pool_1 = MaxPooling2D(pool_size=(2, 2))() #16 x 16 x 128
# # drop6=Dropout(dropRate)(CNN_pool_1)
# CNN_conv_1 = Conv2D(512, (2, 2), activation='relu')(pool2) #1 x 1 x 64
# # drop7=Dropout(dropRate)(CNN_conv_1)
# CNN_pool_1 = MaxPooling2D(pool_size=(2, 2))(CNN_conv_1)
#CNN_pool_2 = MaxPooling2D(pool_size=(2, 2))(CNN_conv_1) #7 x 7 x 64
# flat1 = Flatten()(conv4)
# dense1=Dense(2048, activation='relu')(flat1)
# classifer=Dense(1175, activation='softmax')(dense1)
return decoded
def buildFCN(model,imgSize=224,categories=21):
#os
model.add(Permute((1,2,3),input_shape = (imgSize,imgSize,3)))
# Downsampling path #
#1st block
#Adding convolution layers
model.add(Convolution2D(64,kernel_size = (3,3),padding = "same",activation = "relu",name = "block1_conv1"))
model.add(Convolution2D(64,kernel_size = (3,3),padding = "same",activation = "relu",name = "block1_conv2"))
#Addding max pooling layer
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2),name = 'block1_pool'))
#2nd block
#Adding convolution layers
model.add(Convolution2D(128,kernel_size = (3,3),padding = "same",activation = "relu",name = "block2_conv1"))
model.add(Convolution2D(128,kernel_size = (3,3),padding = "same",activation = "relu",name = "block2_conv2"))
#Addding max pooling layer
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2),name = 'block2_pool'))
#3rd block
#Adding convolution layers
model.add(Convolution2D(256,kernel_size = (3,3),padding = "same",activation = "relu",name = "block3_conv1"))
model.add(Convolution2D(256,kernel_size = (3,3),padding = "same",activation = "relu",name = "block3_conv2"))
model.add(Convolution2D(256,kernel_size = (3,3),padding = "same",activation = "relu",name = "block3_conv3"))
#Addding max pooling layer
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2),name = 'block3_pool'))
#4th block
#Adding convolution layers
model.add(Convolution2D(512,kernel_size = (3,3),padding = "same",activation = "relu",name = "block4_conv1"))
model.add(Convolution2D(512,kernel_size = (3,3),padding = "same",activation = "relu",name = "block4_conv2"))
model.add(Convolution2D(512,kernel_size = (3,3),padding = "same",activation = "relu",name = "block4_conv3"))
#Addding max pooling layer
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2),name = 'block4_pool'))
#5th block
#Adding convolution layers
model.add(Convolution2D(512,kernel_size = (3,3),padding = "same",activation = "relu",name = "block5_conv1"))
model.add(Convolution2D(512,kernel_size = (3,3),padding = "same",activation = "relu",name = "block5_conv2"))
model.add(Convolution2D(512,kernel_size = (3,3),padding = "same",activation = "relu",name = "block5_conv3"))
#Adding max pooling layer
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2),name = 'block5_pool'))
model.add(Convolution2D(4096,kernel_size=(7,7),padding = "same",activation = "relu",name = "fc6"))
#Replacing fully connnected layers of VGG Net using convolutions
model.add(Convolution2D(4096,kernel_size=(1,1),padding = "same",activation = "relu",name = "fc7"))
# Gives the classifications scores for each of the N classes including background
model.add(Convolution2D(categories,kernel_size=(1,1),padding="same",activation="relu",name = "score_fr"))
#Save convolution size
desiredSize=model.layers[-1].output_shape[2]
# Upsampling #
#First deconv layer
model.add(Deconvolution2D(categories,kernel_size=(4,4),strides = (2,2),padding = "valid"))
actualSize=model.layers[-1].output_shape[2]
extra=actualSize-2*desiredSize
#Cropping to get correct size
model.add(Cropping2D(cropping=((0,extra),(0,extra))))
Conv_size = model.layers[-1].output_shape[2]
#Conv to be applied on Pool4
skip_con1 = Convolution2D(categories,kernel_size=(1,1),padding = "same",activation=None, name = "score_pool4")
#Addig skip connection which takes adds the output of Max pooling layer 4 to current layer
Summed = add(inputs = [skip_con1(model.layers[14].output),model.layers[-1].output])
#Upsampling output of first skip connection
x = Deconvolution2D(categories,kernel_size=(4,4),strides = (2,2),padding = "valid",activation=None,name = "score4")(Summed)
x = Cropping2D(cropping=((0,2),(0,2)))(x)
#Conv to be applied to pool3
skip_con2 = Convolution2D(categories,kernel_size=(1,1),padding = "same",activation=None, name = "score_pool3")
#Adding skip connection which takes output og Max pooling layer 3 to current layer
Summed = add(inputs = [skip_con2(model.layers[10].output),x])
#Final Up convolution which restores the original image size
Up = Deconvolution2D(categories,kernel_size=(16,16),strides = (8,8),
padding = "valid",activation = None,name = "upsample")(Summed)
#Cropping the extra part obtained due to transpose convolution
final = Cropping2D(cropping = ((0,8),(0,8)))(Up)
return Model(model.input, final)
# instantiate encoder model encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') #encoder.summary() plot_model(encoder, to_file='vae_mlp_encoder.png', show_shapes=True) # build decoder model latent_inputs = Input(shape=(latent_dim,), name='z_sampling') latent_inputs.shape x = Dense(intermediate_dim, activation='relu', input_shape=(latent_dim,))(latent_inputs) x.shape yy = Dense(intermediate_dim, activation='relu', input_shape=(intermediate_dim,))(x) yy.shape yy = Reshape((16,16,2))(yy) #y.reshape(8,8,8) yy.shape x = Deconvolution2D(16, (3, 3), activation='relu', padding='same', input_shape=(16,16,2))(yy) x.shape x = UpSampling2D((2, 2), input_shape=(16,16,16))(x) x.shape x = Deconvolution2D(8, (3, 3), activation='relu', padding='same', input_shape=(32,32,16))(x) x.shape x = UpSampling2D((2, 2), input_shape=(32,32,8))(x) x.shape x = Deconvolution2D(3, (3, 3), activation='relu', padding='same', input_shape=(64,64,8))(x) x.shape x = UpSampling2D((2, 2), input_shape=(64,64,3))(x) x.shape outputs = Deconvolution2D(1, (3, 3), activation='sigmoid', padding='same', input_shape=(128,128,3))(x) outputs.shape outputs = UpSampling2D((1, 1), input_shape=(128,128,1))(outputs) outputs.shape
def FCN(FCN_CLASSES = 21):
#(samples, channels, rows, cols)
input_img = Input(shape=(3, 224, 224))
#(3*224*224)
x = Convolution2D(64, 3, 3, activation='relu',border_mode='same')(input_img)
x = Convolution2D(64, 3, 3, activation='relu',border_mode='same')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#(64*112*112)
x = Convolution2D(128, 3, 3, activation='relu',border_mode='same')(x)
x = Convolution2D(128, 3, 3, activation='relu',border_mode='same')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#(128*56*56)
x = Convolution2D(256, 3, 3, activation='relu',border_mode='same')(x)
x = Convolution2D(256, 3, 3, activation='relu',border_mode='same')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#(256*56*56)
#split layer
p3 = x
p3 = Convolution2D(FCN_CLASSES, 1, 1,activation='relu')(p3)
#(21*28*28)
x = Convolution2D(512, 3, 3, activation='relu',border_mode='same')(x)
x = Convolution2D(512, 3, 3, activation='relu',border_mode='same')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#(512*14*14)
#split layer
p4 = x
p4 = Convolution2D(FCN_CLASSES, 1, 1, activation='relu')(p4)
p4 = Deconvolution2D(FCN_CLASSES, 4, 4,
output_shape=(None, FCN_CLASSES, 30, 30),
subsample=(2, 2),
border_mode='valid')(p4)
p4 = Cropping2D(cropping=((1, 1), (1, 1)))(p4)
#(21*28*28)
x = Convolution2D(512, 3, 3, activation='relu',border_mode='same')(x)
x = Convolution2D(512, 3, 3, activation='relu',border_mode='same')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#(512*7*7)
p5 = x
p5 = Convolution2D(FCN_CLASSES, 1, 1, activation='relu')(p5)
p5 = Deconvolution2D(FCN_CLASSES, 8, 8,
output_shape=(None, FCN_CLASSES, 32, 32),
subsample=(4, 4),
border_mode='valid')(p5)
p5 = Cropping2D(cropping=((2, 2), (2, 2)))(p5)
#(21*28*28)
# merge scores
merged = merge([p3, p4, p5], mode='sum')
x = Deconvolution2D(FCN_CLASSES, 16, 16,
output_shape=(None, FCN_CLASSES, 232, 232),
subsample=(8, 8),
border_mode='valid')(merged)
x = Cropping2D(cropping=((4, 4), (4, 4)))(x)
x = Reshape((FCN_CLASSES,224*224))(x)
x = Permute((2,1))(x)
out = Activation("softmax")(x)
#(21,224,224)
model = Model(input_img, out)
return model
def model_EED(input_col, input_row):
_input = Input(shape=(input_col, input_row, 1), name='input')
Feature = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(_input)
Feature = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Feature)
Feature3 = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Feature)
Feature_out = merge(inputs=[Feature, Feature3], mode='sum')
# Upsampling
Upsampling1 = Conv2D(nb_filter=8,
nb_row=1,
nb_col=1,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Feature_out)
Upsampling2 = Deconvolution2D(nb_filter=8,
nb_row=14,
nb_col=14,
output_shape=(None, input_col * 2,
input_row * 2, 8),
subsample=(2, 2),
border_mode='same',
init='glorot_uniform',
activation='relu')(Upsampling1)
Upsampling3 = Conv2D(nb_filter=64,
nb_row=1,
nb_col=1,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Upsampling2)
# Mulyi-scale Reconstruction
Reslayer1 = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Upsampling3)
Reslayer2 = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Reslayer1)
Block1 = merge(inputs=[Reslayer1, Reslayer2], mode='sum')
Reslayer3 = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Block1)
Reslayer4 = Conv2D(nb_filter=64,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Reslayer3)
Block2 = merge(inputs=[Reslayer3, Reslayer4], mode='sum')
# ***************//
Multi_scale1 = Conv2D(nb_filter=16,
nb_row=1,
nb_col=1,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Block2)
Multi_scale2a = Conv2D(nb_filter=16,
nb_row=1,
nb_col=1,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Multi_scale1)
Multi_scale2b = Conv2D(nb_filter=16,
nb_row=3,
nb_col=3,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Multi_scale1)
Multi_scale2c = Conv2D(nb_filter=16,
nb_row=5,
nb_col=5,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Multi_scale1)
Multi_scale2d = Conv2D(nb_filter=16,
nb_row=7,
nb_col=7,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Multi_scale1)
Multi_scale2 = merge(
inputs=[Multi_scale2a, Multi_scale2b, Multi_scale2c, Multi_scale2d],
mode='concat')
out = Conv2D(nb_filter=1,
nb_row=1,
nb_col=1,
init='glorot_uniform',
activation='relu',
border_mode='same',
bias=True)(Multi_scale2)
model = Model(input=_input, output=out)
Adam = adam(lr=0.001)
model.compile(optimizer=Adam,
loss='mean_squared_error',
metrics=['mean_squared_error'])
return model
def fcn32_blank(image_size=512):
withDO = False # no effect during evaluation but usefull for fine-tuning
if True:
mdl = Sequential()
# First layer is a dummy-permutation = Identity to specify input shape
mdl.add(Permute((1, 2, 3),
input_shape=(image_size, image_size,
3))) # WARNING : axis 0 is the sample dim
for l in convblock(64, 1, bits=2):
mdl.add(l)
for l in convblock(128, 2, bits=2):
mdl.add(l)
for l in convblock(256, 3, bits=3):
mdl.add(l)
for l in convblock(512, 4, bits=3):
mdl.add(l)
for l in convblock(512, 5, bits=3):
mdl.add(l)
mdl.add(
Convolution2D(4096,
kernel_size=(7, 7),
padding='same',
activation='relu',
name='fc6')) # WARNING border
if withDO:
mdl.add(Dropout(0.5))
mdl.add(
Convolution2D(4096,
kernel_size=(1, 1),
padding='same',
activation='relu',
name='fc7')) # WARNING border
if withDO:
mdl.add(Dropout(0.5))
# WARNING : model decapitation i.e. remove the classifier step of VGG16 (usually named fc8)
mdl.add(
Convolution2D(21,
kernel_size=(1, 1),
padding='same',
activation='relu',
name='score_fr'))
convsize = mdl.layers[-1].output_shape[2]
deconv_output_size = (convsize -
1) * 2 + 4 # INFO: =34 when images are 512x512
# WARNING : valid, same or full ?
mdl.add(
Deconvolution2D(21,
kernel_size=(4, 4),
strides=(2, 2),
padding='valid',
activation=None,
name='score2'))
extra_margin = deconv_output_size - convsize * 2 # INFO: =2 when images are 512x512
assert (extra_margin > 0)
assert (extra_margin % 2 == 0)
# INFO : cropping as deconv gained pixels
# print(extra_margin)
c = ((0, extra_margin), (0, extra_margin))
# print(c)
mdl.add(Cropping2D(cropping=c))
# print(mdl.summary())
return mdl
else:
# See following link for a version based on Keras functional API :
# gist.github.com/EncodeTS/6bbe8cb8bebad7a672f0d872561782d9
raise ValueError('not implemented')
def autoencoder_CNN(input_img):
dropRate = 0.5
#drop_input=Dropout(dropRate)(input_img)
conv1 = Conv2D(64, (3, 3), activation='relu',
padding='same')(input_img) #28 x 28 x 32
#norm1=BatchNormalization()(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) #14 x 14 x 32
#drop1=Dropout(dropRate)(pool1)
conv2 = Conv2D(128, (3, 3), activation='relu',
padding='same')(pool1) #14 x 14 x 64
#norm2=BatchNormalization()(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) #7 x 7 x 64
#drop2=Dropout(dropRate)(pool2)
conv3 = Conv2D(256, (3, 3), activation='relu',
padding='same')(pool2) #7 x 7 x 128 (small and thick)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) #7 x 7 x 64
# # #norm3=BatchNormalization()(conv3)
conv4 = Conv2D(512, (3, 3), activation='relu',
padding='same')(pool3) #7 x 7 x 128 (small and thick)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4) #7 x 7 x 64
conv5 = Conv2D(1024, (3, 3), activation='relu',
padding='same')(pool4) #7 x 7 x 128 (small and thick)
pool5 = MaxPooling2D(pool_size=(2, 2))(conv5) #7 x 7 x 64
conv6 = Conv2D(4096, (4, 4),
activation='relu')(pool5) #7 x 7 x 128 (small and thick)
# #decoder
# de_conv1 = Deconvolution2D(512, (3, 3), activation='relu',output_shape=(None,1,14,14))(conv4) #7 x 7 x 128
# up1 = UpSampling2D((2,2))(de_conv1)
de_conv1 = Deconvolution2D(1024, (4, 4),
activation='relu',
output_shape=(None, 1, 4,
4))(conv6) #7 x 7 x 128
up2 = UpSampling2D((2, 2))(de_conv1)
de_conv3 = Conv2D(512, (3, 3), activation='relu',
padding='same')(up2) #7 x 7 x 128
up3 = UpSampling2D((2, 2))(de_conv3)
de_conv4 = Conv2D(256, (3, 3), activation='relu',
padding='same')(up3) #7 x 7 x 128
up4 = UpSampling2D((2, 2))(de_conv4)
de_conv5 = Conv2D(128, (3, 3), activation='relu',
padding='same')(up4) #7 x 7 x 128
up5 = UpSampling2D((2, 2))(de_conv5)
de_conv6 = Conv2D(64, (3, 3), activation='relu',
padding='same')(up5) #7 x 7 x 128
up6 = UpSampling2D((2, 2))(de_conv6)
de_conv7 = Conv2D(1, (3, 3), activation='relu',
padding='same')(up6) #7 x 7 x 128
decoded = de_conv7
return decoded
def get_model(args):
# Dataset config
config = data_constants[args.dataset.lower()]
inputCNNshape = config['inputCNNshape']
inputMLPshape = config['inputMLPshape']
nb_classes = config['nb_classes']
# Build the CNN
inputCNN = Input(shape=inputCNNshape)
inputNorm = Flatten()(inputCNN)
inputNorm = BatchNormalization(input_shape=inputCNNshape)(inputNorm)
inputNorm = layers.Reshape(inputCNNshape)(inputNorm)
# conv = Convolution2D(16, 3, 3, border_mode='same', activation='relu')(inputNorm)
# conv = Convolution2D(32, 3, 3, border_mode='same', activation='relu')(conv)
# conv = Convolution2D(64, 3, 3, border_mode='same', activation='relu')(conv)
# conv = BatchNormalization()(conv)
# pool = MaxPooling2D((2, 2), strides=(2, 2))(conv)
# Build the CNN
inputCNN = Input(shape=inputCNNshape)
inputNorm = Flatten()(inputCNN)
inputNorm = BatchNormalization(input_shape=inputCNNshape)(inputNorm)
inputNorm = layers.Reshape(inputCNNshape)(inputNorm)
# conv1
conv = Convolution2D(16, 3, 3, border_mode='same',
activation='relu')(inputNorm)
conv = Convolution2D(16, 3, 3, border_mode='same', activation='relu')(conv)
conv = BatchNormalization()(conv)
pool = MaxPooling2D((2, 2), strides=(2, 2))(conv)
pool = Dropout(0.25)(pool)
# conv2
conv = Convolution2D(32, 3, 3, border_mode='same', activation='relu')(pool)
conv = Convolution2D(32, 3, 3, border_mode='same', activation='relu')(conv)
conv = BatchNormalization()(conv)
pool = MaxPooling2D((2, 2), strides=(2, 2))(conv)
pool = Dropout(0.25)(pool)
# conv3
conv = Convolution2D(64, 3, 3, border_mode='same', activation='relu')(pool)
conv = Convolution2D(64, 3, 3, border_mode='same', activation='relu')(conv)
conv = BatchNormalization()(conv)
pool = MaxPooling2D((2, 2), strides=(2, 2))(conv)
pool = Dropout(0.25)(pool)
# conv4
conv = Convolution2D(128, 3, 3, border_mode='same',
activation='relu')(pool)
conv = Convolution2D(128, 3, 3, border_mode='same',
activation='relu')(conv)
conv = cbam_block(conv)
conv = BatchNormalization()(conv)
pool = MaxPooling2D((2, 2), strides=(2, 2))(conv)
pool = Dropout(0.25)(pool)
reshape = Flatten()(pool)
fcCNN = Dense(256, activation='relu')(reshape)
# Build the MLP to CNN for cross-connections
inputMLP = Input(shape=inputMLPshape)
fcMLP = Dense(128, activation='relu')(inputMLP)
fcMLP = BatchNormalization()(fcMLP)
fcMLP = Dropout(0.5)(fcMLP)
x12 = Dense(24 * 24)(fcMLP)
x12 = PReLU()(x12)
x12 = BatchNormalization()(x12)
x12 = Dropout(0.5)(x12)
x12 = Reshape((24, 24, 1))(x12)
x12 = Deconvolution2D(16,
9,
9,
output_shape=(None, 40, 30, 16),
border_mode='valid')(x12)
fcMLPTOCNN = PReLU()(x12)
try:
# Multimodal bilinear pooling
merged = merge([fcCNN, fcMLPTOCNN], compact_bilinear)
except:
merged = merge.concatenate([fcCNN, fcMLP])
merged = BatchNormalization()(merged)
merged = Dropout(0.5)(merged)
fc = Dense(512, activation='relu')(merged)
fc = Dropout(0.5)(fc)
out = Dense(nb_classes, activation='softmax')(fc)
# Return the model object
model = Model(input=[inputCNN, inputMLP], output=out)
return model
def get_unet1():
inputs = Input((1, img_rows, img_cols))
conv1 = Convolution2D(32,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(inputs)
conv1 = Convolution2D(32,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Convolution2D(64,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(pool1)
conv2 = Convolution2D(64,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Convolution2D(128,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(pool2)
conv3 = Convolution2D(128,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Convolution2D(256,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(pool3)
conv4 = Convolution2D(256,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Convolution2D(512,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(pool4)
conv5 = Convolution2D(512,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv5)
up6 = merge([Deconvolution2D(size=(2, 2))(conv5), conv4],
mode='concat',
concat_axis=1)
conv6 = Convolution2D(256,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(up6)
conv6 = Convolution2D(256,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv6)
up7 = merge([Deconvolution2D(size=(2, 2))(conv6), conv3],
mode='concat',
concat_axis=1)
conv7 = Convolution2D(128,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(up7)
conv7 = Convolution2D(128,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv7)
up8 = merge([Deconvolution2D(size=(2, 2))(conv7), conv2],
mode='concat',
concat_axis=1)
conv8 = Convolution2D(64,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(up8)
conv8 = Convolution2D(64,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv8)
up9 = merge([Deconvolution2D(size=(2, 2))(conv8), conv1],
mode='concat',
concat_axis=1)
conv9 = Convolution2D(32,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(up9)
conv9 = Convolution2D(32,
3,
3,
activation='relu',
border_mode='same',
init='he_uniform')(conv9)
conv10 = Convolution2D(1, 1, 1, activation='sigmoid')(conv9)
model = Model(input=inputs, output=conv10)
model.compile(optimizer=Adam(lr=1e-5),
loss=dice_coef_loss,
metrics=[dice_coef])
return model
def create_model(self, train_flag=True):
#(samples, channels, rows, cols)
ip = Input(shape=(3,self.img_height, self.img_width))
h = self.vgg16.layers[1](ip)
h = self.vgg16.layers[2](h)
h = self.vgg16.layers[3](h)
h = self.vgg16.layers[4](h)
h = self.vgg16.layers[5](h)
h = self.vgg16.layers[6](h)
h = self.vgg16.layers[7](h)
h = self.vgg16.layers[8](h)
h = self.vgg16.layers[9](h)
h = self.vgg16.layers[10](h)
#split layer
p3 = h
p3 = Convolution2D(self.FCN_CLASSES, 1, 1, activation='relu', border_mode='valid')(p3)
#(21*28*28)
h = self.vgg16.layers[11](h)
h = self.vgg16.layers[12](h)
h = self.vgg16.layers[13](h)
h = self.vgg16.layers[14](h)
#(512*14*14)
#split layer
p4 = h
p4 = Convolution2D(self.FCN_CLASSES, 1, 1, activation='relu')(p4)
#"""
p4 = Deconvolution2D(self.FCN_CLASSES, 4, 4,
output_shape=(self.batchsize, self.FCN_CLASSES, 30, 30),
subsample=(2, 2),
border_mode='valid')(p4)
p4 = Cropping2D(cropping=((1, 1), (1, 1)))(p4)
#"""
#p4 = UpSampling2D((2,2))(p4)
#p4 = Convolution2D(self.FCN_CLASSES, 3, 3, activation='relu', border_mode='same')(p4)
h = self.vgg16.layers[15](h)
h = self.vgg16.layers[16](h)
h = self.vgg16.layers[17](h)
h = self.vgg16.layers[18](h)
p5 = h
p5 = Convolution2D(self.FCN_CLASSES, 1, 1, activation='relu')(p5)
#"""
p5 = Deconvolution2D(self.FCN_CLASSES, 8, 8,
output_shape=(self.batchsize, self.FCN_CLASSES, 32, 32),
subsample=(4, 4),
border_mode='valid')(p5)
p5 = Cropping2D(cropping=((2, 2), (2, 2)))(p5)
#"""
#p5 = UpSampling2D((4, 4))(p5)
#p5 = Convolution2D(self.FCN_CLASSES, 3, 3, activation='relu', border_mode='same')(p5)
# merge scores
h = merge([p3, p4, p5], mode="sum")
#"""
h = Deconvolution2D(self.FCN_CLASSES, 16, 16,
output_shape=(self.batchsize, self.FCN_CLASSES, 232, 232),
subsample=(8, 8),
border_mode='valid')(h)
#"""
#h = UpSampling2D((8, 8))(h)
#h = Convolution2D(self.FCN_CLASSES, 3, 3, activation='relu', border_mode='same')(h)
h = Cropping2D(cropping=((4, 4), (4, 4)))(h)
#model_temp = Model(ip, h)
#model_temp.summary()
if not train_flag:
return Model(ip, h)
h = Reshape((self.FCN_CLASSES,self.img_height*self.img_width))(h)
h = Permute((2,1))(h)
out = Activation("softmax")(h)
train_model = Model(ip, out)
return train_model
def unet(img_shape):
inputs = Input(shape=img_shape)
conv1 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(inputs)
conv1 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(pool1)
conv2 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(pool2)
conv3 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(pool3)
conv4 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(pool4)
conv5 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv5)
pool5 = MaxPooling2D(pool_size=(2, 2))(conv5)
conv_ext1 = Convolution2D(1024, 3, 3, activation='relu',
border_mode='same')(pool5)
conv_ext1 = Convolution2D(1024, 3, 3, activation='relu',
border_mode='same')(conv_ext1)
up_ext6 = merge([Deconvolution2D(512, 2, 2,
output_shape=(None, 32, 32, 512),
activation='relu', subsample=(2, 2),
border_mode='same')(conv_ext1), conv5],
mode='concat', concat_axis=3)
conv_ext2 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(up_ext6)
conv_ext2 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv_ext2)
up6 = merge([Deconvolution2D(256, 2, 2,
output_shape=(None, 64, 64, 256),
activation='relu', subsample=(2, 2),
border_mode='same')(conv_ext2), conv4],
mode='concat', concat_axis=3)
# # up6 = merge([UpSampling2D(size=(2, 2))(conv5), conv_ext2],
# # mode='concat', concat_axis=3)
conv6 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(up6)
conv6 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv6)
up7 = merge([Deconvolution2D(128, 2, 2,
output_shape=(None, 128, 128, 128),
activation='relu', subsample=(2, 2),
border_mode='same')(conv6), conv3],
mode='concat', concat_axis=3)
conv7 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(up7)
conv7 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(conv7)
up8 = merge([Deconvolution2D(64, 2, 2,
output_shape=(None, 256, 256, 64),
activation='relu', subsample=(2, 2),
border_mode='same')(conv7), conv2],
mode='concat', concat_axis=3)
conv8 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(up8)
conv8 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(conv8)
up9 = merge([Deconvolution2D(32, 2, 2,
output_shape=(None, 512, 512, 32),
activation='relu', subsample=(2, 2),
border_mode='same')(conv8), conv1],
mode='concat', concat_axis=3)
conv9 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(up9)
conv9 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(conv9)
conv10 = Convolution2D(1, 1, 1, activation='sigmoid')(conv9)
flat = Flatten(name='flatten')(conv9)
dense1 = Dense(64, activation='relu', name='fc1')(flat)
dense2 = Dense(64, activation='relu', name='fc2')(dense1)
dense = Dense(8, activation='softmax', name='predictions')(dense2)
model = Model(input=inputs, output=[conv10, dense])
# model = Model(input=inputs, output=[conv10])
model.compile(optimizer=Adam(lr=1e-5), loss=[dice_coef_loss,
'categorical_crossentropy'],
metrics=[dice_coef, 'accuracy'])
# model.compile(optimizer=Adam(lr=1e-5), loss=[dice_coef_loss],
# metrics=[dice_coef])
return model
def YOLSEModel(input_shape=(128, 128, 3)):
input_ = Input(shape=input_shape)
x = conv_bn_relu(filters=96,
name={
'conv': 'conv1',
'batch_norm': 'BN1',
'activation': 'act1'
})(input_)
x = MaxPool2D(name='pool_01')(x)
x = conv_bn_relu(filters=96,
name={
'conv': 'conv2',
'batch_norm': 'BN2',
'activation': 'act2'
})(x)
x = MaxPool2D(name='pool_02')(x)
x = conv_bn_relu(filters=128,
name={
'conv': 'conv3',
'batch_norm': 'BN3',
'activation': 'act3'
})(x)
upsample = Deconvolution2D(filters=128,
kernel_size=(3, 3),
strides=(2, 2),
activation='relu',
padding='same')(x)
x = conv_bn_relu(filters=256,
name={
'conv': 'conv4',
'batch_norm': 'BN4',
'activation': 'act4'
})(upsample)
x = conv_bn_relu(filters=256,
name={
'conv': 'conv5',
'batch_norm': 'BN5',
'activation': 'act5'
})(x)
x = conv_bn_relu(filters=256,
name={
'conv': 'conv6',
'batch_norm': 'BN6',
'activation': 'act6'
})(x)
x = conv_bn_relu(filters=256,
name={
'conv': 'conv7',
'batch_norm': 'BN7',
'activation': 'act7'
})(x)
x = Concatenate()([x, upsample])
x = conv_bn_relu(filters=128,
name={
'conv': 'conv8',
'batch_norm': 'BN8',
'activation': 'act8'
})(x)
x = Conv2D(filters=5,
kernel_size=(3, 3),
padding='same',
activation='sigmoid')(x)
return Model(inputs=input_, outputs=x)
def get_uplusnet(): inputs = Input((640, 640, 1)) nb_filters = 64 conv1a = Convolution2D(nb_filters*1, 3, 3, activation='relu', border_mode='same')(inputs) conv1a = Residual(nb_filters*1, nb_filters*1, conv1a) conv1a = Convolution2D(nb_filters*1, 3, 3, activation='relu', border_mode='same')(conv1a) conv1a = Dropout(p=0.25)(conv1a) pool1a = MaxPooling2D(pool_size=(2, 2))(conv1a) conv2a = Convolution2D(nb_filters*2, 3, 3, activation='relu', border_mode='same')(pool1a) conv2a = Residual(nb_filters*2, nb_filters*2, conv2a) conv2a = Convolution2D(nb_filters*2, 3, 3, activation='relu', border_mode='same')(conv2a) conv2a = Dropout(p=0.25)(conv2a) pool2a = MaxPooling2D(pool_size=(2, 2))(conv2a) conv3a = Convolution2D(nb_filters*4, 3, 3, activation='relu', border_mode='same')(pool2a) conv3a = Residual(nb_filters*4, nb_filters*4, conv3a) conv3a = Convolution2D(nb_filters*4, 3, 3, activation='relu', border_mode='same')(conv3a) conv3a = Dropout(p=0.25)(conv3a) pool3a = MaxPooling2D(pool_size=(2, 2))(conv3a) conv4a = Convolution2D(nb_filters*8, 3, 3, activation='relu', border_mode='same')(pool3a) conv4a = Residual(nb_filters*8, nb_filters*8, conv4a) conv4a = Convolution2D(nb_filters*8, 3, 3, activation='relu', border_mode='same')(conv4a) conv4a = Dropout(p=0.25)(conv4a) pool4a = MaxPooling2D(pool_size=(2, 2))(conv4a) conv5a = Convolution2D(nb_filters*16, 3, 3, activation='relu', border_mode='same')(pool4a) conv5a = Residual(nb_filters*16, nb_filters*16, conv5a) conv5a = Dropout(p=0.25)(conv5a) conv5a = Convolution2D(nb_filters*16, 3, 3, activation='relu', border_mode='same')(conv5a) up6a = Convolution2D(nb_filters*8, 3, 3, activation='relu', border_mode='same')(conv5a) # up6a = UpSampling2D(size=(2, 2))(up6a) up6a = Deconvolution2D(nb_filters*8, 3, 3, input_shape=(nb_filters*8, 40, 40), output_shape=(1, 80, 80, nb_filters*8), subsample=(2, 2), activation='relu', border_mode='same')(up6a) conv6a = merge([up6a, conv4a], mode='sum') conv6a = Dropout(p=0.25)(conv6a) conv6a = Residual(nb_filters*8, nb_filters*8, conv6a) conv6a = Convolution2D(nb_filters*8, 3, 3, activation='relu', border_mode='same')(conv6a) up7a = Convolution2D(nb_filters*4, 3, 3, activation='relu', border_mode='same')(conv6a) # up7a = UpSampling2D(size=(2, 2))(up7a) up7a = Deconvolution2D(nb_filters*4, 3, 3, input_shape=(nb_filters*4, 80, 80), output_shape=(1, 160, 160, nb_filters*4), subsample=(2, 2), activation='relu', border_mode='same')(up7a) conv7a = merge([up7a, conv3a], mode='sum') conv7a = Dropout(p=0.25)(conv7a) conv7a = Residual(nb_filters*4, nb_filters*4, conv7a) conv7a = Convolution2D(nb_filters*4, 3, 3, activation='relu', border_mode='same')(conv7a) up8a = Convolution2D(nb_filters*2, 3, 3, activation='relu', border_mode='same')(conv7a) # up8a = UpSampling2D(size=(2, 2))(up8a) up8a = Deconvolution2D(nb_filters*2, 3, 3, input_shape=(nb_filters*4, 160, 160), output_shape=(1, 320, 320, nb_filters*2), subsample=(2, 2), activation='relu', border_mode='same')(up8a) conv8a = merge([up8a, conv2a], mode='sum') conv8a = Dropout(p=0.25)(conv8a) conv8a = Residual(nb_filters*2, nb_filters*2, conv8a) conv8a = Convolution2D(nb_filters*2, 3, 3, activation='relu', border_mode='same')(conv8a) up9a = Convolution2D(nb_filters*1, 3, 3, activation='relu', border_mode='same')(conv8a) # up9a = UpSampling2D(size=(2, 2))(up9a) up9a = Deconvolution2D(nb_filters*1, 3, 3, input_shape=(nb_filters*1, 320, 320), output_shape=(1, 640, 640, nb_filters*1), subsample=(2, 2), activation='relu', border_mode='same')(up9a) conv9a = merge([up9a, conv1a], mode='sum') conv9a = Dropout(p=0.25)(conv9a) conv9a = Residual(nb_filters*1, nb_filters*1, conv9a) conv9a = Convolution2D(nb_filters*1, 3, 3, activation='relu', border_mode='same')(conv9a) conv10 = Convolution2D(1, 1, 1, activation='sigmoid')(conv9a) model = Model(input=inputs, output=conv10) model.compile(optimizer=Nadam(lr=0.0001), loss='mae') model.summary() return model
def __init__(self, input_shape=(28, 28, 1), latent_dim=2, intermediate_dim=256, batch_size=100, epsilon_std=1.0,
dropout_p=0.1):
# input image dimensions
self.input_shape = input_shape
if len(input_shape) == 3:
self.img_rows, self.img_cols, self.img_chns = input_shape
elif len(input_shape) == 2:
self.img_rows, self.img_cols = input_shape
self.img_chns = 1
else:
raise IndexError("Invalid shape: {}".format(input_shape))
self.batch_size = batch_size
self.original_dim = np.prod(input_shape)
self.latent_dim = latent_dim
self.intermediate_dim = intermediate_dim
self.epsilon_std = epsilon_std
# number of convolutional filters to use
nb_filters = 64
# convolution kernel size
nb_conv = 3
batch_size = 100
if K_backend.image_dim_ordering() == 'th':
self.original_img_size = (self.img_chns, self.img_rows, self.img_cols)
else:
self.original_img_size = (self.img_rows, self.img_cols, self.img_chns)
x = Input(batch_shape=(batch_size,) + self.original_img_size)
conv_1 = Convolution2D(self.img_chns, 2, 2, border_mode='same', activation='relu')(x)
conv_2 = Convolution2D(nb_filters, 2, 2,
border_mode='same', activation='relu', subsample=(2, 2))(conv_1)
conv_3 = Convolution2D(nb_filters, nb_conv, nb_conv, border_mode='same', activation='relu', subsample=(1, 1))(
conv_2)
for i in range(5):
conv_3 = BatchNormalization()(conv_3)
conv_3 = Dropout(dropout_p)(conv_3)
conv_3 = Convolution2D(nb_filters, nb_conv, nb_conv, border_mode='same', activation='relu',
subsample=(1, 1))(conv_3)
conv_3 = BatchNormalization()(conv_3)
conv_4 = Convolution2D(nb_filters, nb_conv, nb_conv, border_mode='same', activation='relu', subsample=(1, 1))(
conv_3)
flat = Flatten()(conv_4)
hidden = Dense(intermediate_dim, activation='relu')(flat)
self.z_mean = Dense(latent_dim)(hidden)
self.z_log_var = Dense(latent_dim)(hidden)
## ==== End of encoding portion ======
# note that "output_shape" isn't necessary with the TensorFlow backend
# so you could write `Lambda(sampling)([z_mean, z_log_var])`
z = Lambda(self.sampling, output_shape=(latent_dim,))([self.z_mean, self.z_log_var])
# we instantiate these layers separately so as to reuse them later
decoder_hid = Dense(intermediate_dim, activation='relu')
decoder_upsample = Dense(nb_filters * 14 * 14, activation='relu')
if K_backend.image_dim_ordering() == 'th':
output_shape = (batch_size, nb_filters, 14, 14)
else:
output_shape = (batch_size, 14, 14, nb_filters)
decoder_reshape = Reshape(output_shape[1:])
decoder_deconv_1 = Deconvolution2D(nb_filters, nb_conv, nb_conv, output_shape,
border_mode='same', subsample=(1, 1), activation='relu')
decoder_deconv_2 = Deconvolution2D(nb_filters, nb_conv, nb_conv, output_shape,
border_mode='same', subsample=(1, 1), activation='relu')
if K_backend.image_dim_ordering() == 'th':
output_shape = (batch_size, nb_filters, 29, 29)
else:
output_shape = (batch_size, 29, 29, nb_filters)
decoder_deconv_3_upsamp = Deconvolution2D(nb_filters, 2, 2, output_shape,
border_mode='valid', subsample=(2, 2), activation='relu')
decoder_mean_squash = Convolution2D(self.img_chns, 2, 2, border_mode='valid', activation='sigmoid')
hid_decoded = decoder_hid(z)
up_decoded = decoder_upsample(hid_decoded)
reshape_decoded = decoder_reshape(up_decoded)
deconv_1_decoded = decoder_deconv_1(reshape_decoded)
deconv_2_decoded = decoder_deconv_2(deconv_1_decoded)
x_decoded_relu = decoder_deconv_3_upsamp(deconv_2_decoded)
x_decoded_mean_squash = decoder_mean_squash(x_decoded_relu)
self.model = Model(x, x_decoded_mean_squash)
self.model.compile(optimizer='rmsprop', loss=self.vae_loss)
# self.model.summary()
# build a model to project inputs on the latent space
self.encoder = Model(x, self.z_mean)
# build a digit generator that can sample from the learned distribution
# todo: (un)roll this
decoder_input = Input(shape=(latent_dim,))
_hid_decoded = decoder_hid(decoder_input)
_up_decoded = decoder_upsample(_hid_decoded)
_reshape_decoded = decoder_reshape(_up_decoded)
_deconv_1_decoded = decoder_deconv_1(_reshape_decoded)
_deconv_2_decoded = decoder_deconv_2(_deconv_1_decoded)
_x_decoded_relu = decoder_deconv_3_upsamp(_deconv_2_decoded)
_x_decoded_mean_squash = decoder_mean_squash(_x_decoded_relu)
self.generator = Model(decoder_input, _x_decoded_mean_squash)
def get_unet(img_rows, img_cols):
from keras.models import Model
from keras.layers.core import Reshape, Permute, Activation
from keras.layers import Input, merge, Convolution2D, MaxPooling2D, UpSampling2D, Deconvolution2D
from keras.layers.normalization import BatchNormalization
from keras import backend as K
K.set_image_dim_ordering('th')
inputs = Input((1, img_rows, img_cols))
conv1 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(inputs)
conv2 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(pool1)
conv4 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(conv3)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(pool2)
conv6 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv5)
conv6 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv6)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv6)
conv7 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(pool3)
conv8 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv7)
conv8 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv8)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv8)
conv9 = Convolution2D(1024, 3, 3, activation='relu',
border_mode='same')(pool4)
conv10 = Convolution2D(1024, 3, 3, activation='relu',
border_mode='same')(conv9)
deconv1 = Deconvolution2D(512,
2,
2,
output_shape=(batch_size, 512, img_rows / 8,
img_cols / 8),
subsample=(2, 2),
activation='relu')(conv10)
#deconv1 = UpSampling2D(size=(2,2))(conv10)
#deconv1 = Convolution2D(512, 2, 2, activation='relu', border_mode='same')(deconv1)
merge1 = merge([deconv1, conv8], mode='concat', concat_axis=1)
conv11 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(merge1)
conv12 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv11)
conv12 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv12)
deconv2 = Deconvolution2D(256,
2,
2,
output_shape=(batch_size, 256, img_rows / 4,
img_cols / 4),
subsample=(2, 2),
activation='relu')(conv12)
#deconv2 = UpSampling2D(size=(2,2))(conv12)
#deconv2 = Convolution2D(256, 2, 2, activation='relu', border_mode='same')(deconv2)
merge2 = merge([deconv2, conv6], mode='concat', concat_axis=1)
conv13 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(merge2)
conv14 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv13)
conv14 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv14)
deconv3 = Deconvolution2D(128,
2,
2,
output_shape=(batch_size, 128, img_rows / 2,
img_cols / 2),
subsample=(2, 2),
activation='relu')(conv14)
#deconv3 = UpSampling2D(size=(2,2))(conv14)
#deconv3 = Convolution2D(128, 2, 2, activation='relu', border_mode='same')(deconv3)
merge3 = merge([deconv3, conv4], mode='concat', concat_axis=1)
conv15 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(merge3)
conv16 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(conv15)
deconv4 = Deconvolution2D(64,
2,
2,
output_shape=(batch_size, 64, img_rows,
img_cols),
subsample=(2, 2),
activation='relu')(conv16)
#deconv4 = UpSampling2D(size=(2,2))(conv16)
#deconv4 = Convolution2D(64, 2, 2, activation='relu', border_mode='same')(deconv4)
merge4 = merge([deconv4, conv2], mode='concat', concat_axis=1)
conv17 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(merge4)
conv18 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(conv17)
conv19 = Convolution2D(2, 1, 1, activation=None,
border_mode='same')(conv18)
conv19 = Reshape((2, img_rows * img_cols))(conv19)
conv19 = Permute((2, 1))(conv19)
conv19 = Activation('softmax')(conv19)
model = Model(input=inputs, output=conv19)
model.summary()
return model