def get_model():
model = models.Sequential()
model.add(layers.Reshape((30, 30, 30, 1), input_shape=(30, 30, 30, 1)))
model.add(layers.Conv3D(16, 6, strides=2, activation='relu', padding='same'))
model.add(layers.Conv3D(64, 5, strides=2, activation='relu', padding='same'))
model.add(layers.Conv3D(64, 5, strides=2, activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(10, activation='softmax'))
return model
def decoder_block(input_tensor,concat_tensor, num_filters):
decoder = layers.Conv3DTranspose(num_filters,(2,2,2),strides=(2,2,2),padding='same')(input_tensor)
decoder = layers.concatenate([concat_tensor,decoder],axis=-1)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
decoder = layers.Conv3D(num_filters,kernel_size=[3,3,3],padding='same')(decoder)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
decoder = layers.Conv3D(num_filters,kernel_size=[3,3,3],padding='same')(decoder)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
decoder = layers.Conv3D(num_filters,kernel_size=[3,3,3],padding='same')(decoder)
decoder = layers.BatchNormalization()(decoder)
decoder = layers.Activation('relu')(decoder)
return decoder
def Construct3DUnetModel(input_images, nclasses, use_bn = True, use_dropout = True):
with name_scope("contract1"):
x, contract1 = CreateConv3DBlock(input_images, (32, 64), n = 2, use_bn = use_bn, name = 'contract1')
with name_scope("contract2"):
x, contract2 = CreateConv3DBlock(x, (64, 128), n = 2, use_bn = use_bn, name = 'contract2')
with name_scope("contract3"):
x, contract3 = CreateConv3DBlock(x, (128, 256), n = 2, use_bn = use_bn, name = 'contract3')
with name_scope("contract4"):
x, _ = CreateConv3DBlock(x, (256, 512), n = 2, use_bn = use_bn, apply_pooling = False, name = 'contract4')
with name_scope("dropout"):
if use_dropout:
x = klayers.Dropout(0.5, name='dropout')(x)
with name_scope("expand3"):
x = CreateUpConv3DBlock(x, [contract3], (256, 256), n = 2, use_bn = use_bn, name = 'expand3')
with name_scope("expand2"):
x = CreateUpConv3DBlock(x, [contract2], (128, 128), n = 2, use_bn = use_bn, name = 'expand2')
with name_scope("expand1"):
x = CreateUpConv3DBlock(x, [contract1], (64, 64), n = 2, use_bn = use_bn, name = 'expand1')
with name_scope("segmentation"):
layername = 'segmentation_{}classes'.format(nclasses)
x = klayers.Conv3D(nclasses, (1,1,1), activation='softmax', padding='same', name=layername)(x)
return x
def _build(self, params) -> None:
"""
Builds the convolutional network.
use_bias=False in FC/CONV nets because of this article:
https://www.dlology.com/blog/one-simple-trick-to-train-keras-model-faster-with-batch-normalization/
"""
init = layers.Input(shape=((params.image_size, params.image_size,
params.in_channels, 1)))
x = layers.Conv3D(filters=32,
kernel_size=(13, 13, 3),
padding='same',
activation='selu')(init)
x = layers.MaxPool3D(pool_size=(3, 3, 2),
strides=(2, 2, 1),
padding='valid')(x)
x = layers.Conv3D(filters=32,
kernel_size=(7, 7, 3),
padding='same',
activation='selu')(x)
x = layers.MaxPool3D(pool_size=(3, 3, 2),
strides=(2, 2, 1),
padding='valid')(x)
x = layers.Conv3D(filters=48,
kernel_size=(3, 3, 2),
padding='same',
activation='selu')(x)
x = layers.Conv3D(filters=48,
kernel_size=(3, 3, 2),
padding='same',
activation='selu',
name="retrieve")(x)
x = layers.MaxPool3D(pool_size=(3, 3, 2),
strides=(2, 2, 1),
padding='valid')(x)
x = layers.Flatten()(x)
x = layers.Dense(80)(x)
# end of siamese network. We concatenate the output into an array so we can load weights in the right way
x = layers.Dense(units=160, name='dense_last',
activation='selu')(tf.concat([x, x], axis=1))
out = layers.Dense(units=2, name='classifier', activation='sigmoid')(x)
self._model = tf.keras.Model(inputs=init, outputs=out)
def CreateConv3DBlock(x, filters, n = 2, use_bn = True, apply_pooling = True, name = 'convblock'):
for i in range(n):
x = klayers.Conv3D(filters[i], (3,3,3), padding='valid', name=name+'_conv'+str(i+1))(x)
if use_bn:
x = klayers.BatchNormalization(name=name+'_BN'+str(i+1))(x)
x = klayers.Activation('relu', name=name+'_relu'+str(i+1))(x)
convresult = x
if apply_pooling:
x = klayers.MaxPool3D(pool_size=(2,2,2), name=name+'_pooling')(x)
return x, convresult
def discriminator_model(self):
model = tf.keras.Sequential()
# Convolution block 1
model.add(kl.Conv3D(filters=self.crop_size,
input_shape=(self.num_frames, self.crop_size, self.crop_size, 3),
kernel_size=4, strides=2, padding='same', kernel_initializer=self.conv_init))
model.add(kl.Lambda(lambda x: tf.contrib.layers.layer_norm(x)))
model.add(kl.LeakyReLU(.2))
# Convolution block 2
model.add(kl.Conv3D(filters=self.crop_size * 2, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init))
model.add(kl.Lambda(lambda x: tf.contrib.layers.layer_norm(x)))
model.add(kl.LeakyReLU(.2))
# Convolution block 3
model.add(kl.Conv3D(filters=self.crop_size * 4, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init))
model.add(kl.Lambda(lambda x: tf.contrib.layers.layer_norm(x)))
model.add(kl.LeakyReLU(.2))
# Convolution block 4
model.add(kl.Conv3D(filters=self.crop_size * 8, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init))
model.add(kl.Lambda(lambda x: tf.contrib.layers.layer_norm(x)))
model.add(kl.LeakyReLU(.2))
# Convolution block 5
model.add(kl.Conv3D(filters=1, kernel_size=4, strides=2, padding='same',
kernel_initializer=self.conv_init))
model.add(kl.LeakyReLU(.2))
# Linear block
model.add(kl.Flatten())
model.add(kl.Dense(1, kernel_initializer=tf.keras.initializers.random_normal(stddev=0.01)))
return model
def _conv3d_bn(x,
filters,
num_step,
num_row,
num_col,
padding='same',
strides=(1, 1, 1),
name=None):
"""Utility function to apply convolution and batch normalization.
Arguments:
x: The input tensor.
filters: The filters in `Conv3D`.
num_step: The depth of the convolution kernel.
num_row: The height of the convolution kernel.
num_col: The width of the convolution kernel.
padding: The padding mode in `Conv3D`.
strides: The strides in `Conv3D`.
name: The name of the ops; will become `name + '_conv'` for the convolution and `name + '_bn'` for the batch
norm layer.
Returns:
The output tensor after applying `Conv3D` and `BatchNormalization`.
"""
if name is not None:
bn_name = name + '_bn'
conv_name = name + '_conv'
else:
bn_name = None
conv_name = None
x = layers.Conv3D(filters, (num_step, num_row, num_col),
strides=strides,
padding=padding,
use_bias=False,
name=conv_name)(x)
x = layers.BatchNormalization(axis=_CHANNEL_AXIS,
scale=False,
name=bn_name)(x)
x = layers.Activation('relu', name=name)(x)
return x
def Convolutional_LSTM(n_frames, width, height, channels):
# take input movies of shape ( )
input = layers.Input(shape=(n_frames, width, height, channels))
x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(input)
x = layers.BatchNormalization()(x)
x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
x = layers.BatchNormalization()(x)
x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
x = layers.BatchNormalization()(x)
x = layers.ConvLSTM2D(filters=40, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
x = layers.BatchNormalization()(x)
x = layers.Conv3D(filters=1, kernel_size=(3, 3, 3), padding='same', data_format='channels_last')(x)
x = layers.Activation('sigmoid')(x)
conv_lstm = tf.keras.models.Model(input=input, output=x)
conv_lstm.compile(optimizer='adadelta', loss='binary_crossentropy')
# return a movie of identical shape
return conv_lstm
def CreateUpConv3DBlock(x,
contractpart,
filters,
n=2,
use_bn=True,
name='upconvblock'):
# upconv x
x = klayers.Conv3DTranspose((int)(x.shape[-1]), (2, 2, 2),
strides=(2, 2, 2),
padding='same',
use_bias=False,
name=name + '_upconv')(x)
# concatenate contractpart and x
c = [(i - j) // 2 for (
i,
j) in zip(contractpart[0].shape[1:4].as_list(), x.shape[1:4].as_list())
]
contract_crop = klayers.Cropping3D(cropping=((c[0], c[0]), (c[1], c[1]),
(c[2],
c[2])))(contractpart[0])
if len(contractpart) > 1:
crop1 = klayers.Cropping3D(cropping=((c[0], c[0]), (c[1], c[1]),
(c[2], c[2])))(contractpart[1])
#crop2 = klayers.Cropping3D(cropping=((c[0],c[0]),(c[1],c[1]),(c[2],c[2])))(contractpart[2])
#x = klayers.concatenate([contract_crop, crop1, crop2, x])
x = klayers.concatenate([contract_crop, crop1, x])
else:
x = klayers.concatenate([contract_crop, x])
# conv x 2 times
for i in range(n):
x = klayers.Conv3D(filters[i], (3, 3, 3),
padding='valid',
name=name + '_conv' + str(i + 1))(x)
if use_bn:
x = klayers.BatchNormalization(name=name + '_BN' + str(i + 1))(x)
x = klayers.Activation('relu', name=name + '_relu' + str(i + 1))(x)
return x
def convolution():
inn = layers.Input(shape=(sequence_length, alpha_len, embedding_dimension,
1))
cnns = []
for i, size in enumerate(filter_sizes):
conv = layers.Conv3D(
filters=2,
kernel_size=([size, alpha_len, embedding_dimension]),
strides=[size, 1, 1],
padding='valid',
activation='relu')(inn)
#if i%2:
pool_size = int(conv.shape[1] / 100)
pool = layers.MaxPool3D(pool_size=([pool_size, 1, 1]),
padding='valid')(conv)
#pool = MaxMin(pool_size)(conv)
cnns.append(pool)
outt = layers.concatenate(cnns)
model = keras.Model(inputs=inn, outputs=outt, name='cnns')
model.summary()
return model
def conv(input_tensor, num_filters):
encoder = layers.Conv3D(num_filters, kernel_size=[3, 3, 3], padding='same')(input_tensor)
encoder = layers.BatchNormalization()(encoder)
encoder = layers.Activation('relu')(encoder)
return encoder
def output(decoder0):
with tf.name_scope('outputs'):
outputs = layers.Conv3D(1, (1,1,1), activation='sigmoid',name='outputs')(decoder0)
return outputs
def __init__(self, params, **kwargs):
super(SiameseConv, self).__init__(**kwargs)
self.img_size = params.image_size
in_channels = params.in_channels
out_channels = params.out_channels
num_labels = params.num_labels
bn_momentum = params.bn_momentum
self.conv0 = layers.Conv3D(filters=32,
kernel_size=(13, 13, 3),
padding='same',
activation='relu',
input_shape=(self.img_size, self.img_size,
in_channels, 1),
name="pippo")
# self.bn0 = layers.BatchNormalization(momentum=bn_momentum)
self.maxpool0 = layers.MaxPool3D(pool_size=(3, 3, 2),
strides=(2, 2, 1),
padding='valid')
# self.maxpool0 = layers.Conv3D(filters=16, kernel_size=(3, 3, 2), strides=(2, 2, 1), padding='valid')
self.conv1 = layers.Conv3D(filters=32,
kernel_size=(7, 7, 3),
padding='same',
activation='relu')
# self.bn1 = layers.BatchNormalization(momentum=bn_momentum)
self.maxpool1 = layers.MaxPool3D(pool_size=(3, 3, 2),
strides=(2, 2, 1),
padding='valid')
# self.maxpool1 = layers.Conv3D(filters=16, kernel_size=(3, 3, 2), strides=(2, 2, 1), padding='valid')
self.conv2 = layers.Conv3D(filters=48,
kernel_size=(3, 3, 2),
padding='same',
activation='relu')
# self.bn2 = layers.BatchNormalization(momentum=bn_momentum)
# self.maxpool2 = layers.MaxPool3D(pool_size=(3, 3, 2), strides=(2, 2, 1), padding='valid')
self.conv3 = layers.Conv3D(filters=48,
kernel_size=(3, 3, 2),
padding='same',
activation='relu')
# self.bn3 = layers.BatchNormalization(momentum=bn_momentum)
self.maxpool3 = layers.MaxPool3D(pool_size=(3, 3, 2),
strides=(2, 2, 1),
padding='valid')
# self.maxpool3 = layers.Conv3D(filters=16, kernel_size=(3, 3, 2), strides=(2, 2, 1), padding='valid')
# self.conv4 = layers.Conv3D(filters=48, kernel_size=(3, 3, 2), padding='same', activation='relu')
# self.bn4 = layers.BatchNormalization(momentum=bn_momentum)
# self.maxpool4 = layers.MaxPool3D(pool_size=(3, 3, 2), strides=(2, 2, 1), padding='valid')
# self.conv5 = layers.Conv3D(filters=80, kernel_size=(3, 3, 3), padding='same', activation='relu')
# self.bn5 = layers.BatchNormalization(momentum=bn_momentum)
# self.maxpool5 = layers.MaxPool3D(pool_size=(3, 3, 2), strides=(1, 1, 1), padding='valid')
self.flatten = layers.Flatten()
self.fc_siamese = layers.Dense(80)
# self.bn6 = layers.BatchNormalization(momentum=bn_momentum)
# self.dropout_siamese = layers.Dropout(params.dropout_rate)
# output = (None, 30, 30, 128) padding=valid means resize W and H to (W-ks+1)
# ADD DENSE LAYER ON TOP
# To complete our model, we will feed the last output tensor from the convolutional base (of shape (X, X, 64))
# into one or more Dense layers to perform classification.
# Dense layers take vectors as input (which are 1D), while the current output is a 3D tensor.
# First, we will flatten (or unroll) the 3D output to 1D, then add one or more Dense layers on top.
# Since we have 2 output classes, we use a final Dense layer with 2 outputs and a sigmoid activation.
self.fc0 = layers.Dense(units=160,
name='dense_last',
activation='relu')
# self.bn_last = layers.BatchNormalization(momentum=bn_momentum, name='batch_norm_last')
# self.dropout_last = layers.Dropout(rate=params.dropout_rate)
self.classifier = layers.Dense(units=num_labels,
name='classifier',
activation='sigmoid')
