def generator_model():
model = Sequential()
model.add(Dense(input_dim=100, units=2 * 512 * 4 * 4))
model.add(Activation('tanh'))
model.add(BatchNormalization())
# 2x4x4
model.add(Reshape((2, 4, 4, 512), input_shape=(2 * 512 * 4 * 4, )))
model.add(
Conv3D(filters=512,
kernel_size=(2, 4, 4),
strides=(1, 1, 1),
padding='same',
data_format="channels_last"))
model.add(TimeDistributed(BatchNormalization()))
model.add(Dropout(0.5))
# 4x8x8 image
model.add(
Conv3DTranspose(filters=256,
kernel_size=(4, 4, 4),
strides=(2, 2, 2),
padding='same'))
model.add(TimeDistributed(BatchNormalization()))
model.add(TimeDistributed(LeakyReLU(0.2)))
model.add(Dropout(0.5))
# 8x16x16 image
model.add(
Conv3DTranspose(filters=128,
kernel_size=(4, 4, 4),
strides=(2, 2, 2),
padding='same'))
model.add(TimeDistributed(BatchNormalization()))
model.add(TimeDistributed(LeakyReLU(0.2)))
model.add(Dropout(0.5))
# 16x32x32 image
model.add(
Conv3DTranspose(filters=64,
kernel_size=(4, 4, 4),
strides=(2, 2, 2),
padding='same'))
model.add(TimeDistributed(BatchNormalization()))
model.add(TimeDistributed(LeakyReLU(0.2)))
model.add(Dropout(0.5))
# 32x64x64 image
model.add(
Conv3DTranspose(filters=3,
kernel_size=(4, 4, 4),
strides=(2, 2, 2),
padding='same',
activation='tanh'))
return model
def Unet_3d(input_img, n_filters=8, dropout=0.2, batch_norm=True):
c1 = conv_block(input_img, n_filters, 3, batch_norm)
p1 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c1)
p1 = Dropout(dropout)(p1)
c2 = conv_block(p1, n_filters * 2, 3, batch_norm)
p2 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c2)
p2 = Dropout(dropout)(p2)
c3 = conv_block(p2, n_filters * 4, 3, batch_norm)
p3 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c3)
p3 = Dropout(dropout)(p3)
c4 = conv_block(p3, n_filters * 8, 3, batch_norm)
p4 = MaxPooling3D(pool_size=(2, 2, 2), strides=2)(c4)
p4 = Dropout(dropout)(p4)
c5 = conv_block(p4, n_filters * 16, 3, batch_norm)
u6 = Conv3DTranspose(n_filters * 8, (3, 3, 3),
strides=(2, 2, 2),
padding='same')(c5)
u6 = concatenate([u6, c4])
c6 = conv_block(u6, n_filters * 8, 3, batch_norm)
c6 = Dropout(dropout)(c6)
u7 = Conv3DTranspose(n_filters * 4, (3, 3, 3),
strides=(2, 2, 2),
padding='same')(c6)
u7 = concatenate([u7, c3])
c7 = conv_block(u7, n_filters * 4, 3, batch_norm)
c7 = Dropout(dropout)(c7)
u8 = Conv3DTranspose(n_filters * 2, (3, 3, 3),
strides=(2, 2, 2),
padding='same')(c7)
u8 = concatenate([u8, c2])
c8 = conv_block(u8, n_filters * 2, 3, batch_norm)
c8 = Dropout(dropout)(c8)
u9 = Conv3DTranspose(n_filters, (3, 3, 3),
strides=(2, 2, 2),
padding='same')(c8)
u9 = concatenate([u9, c1])
c9 = conv_block(u9, n_filters, 3, batch_norm)
outputs = Conv3D(4, (1, 1, 1), activation='softmax')(c9)
print("!!!!!!!!!!!!!!!!!!!")
print(outputs.shape)
model = Model(inputs=input_img, outputs=outputs)
return model
def unet_model_3d_crop(img_width=128, img_height=128, TIME=10):
'''
Modified from https://keunwoochoi.wordpress.com/2017/10/11/u-net-on-keras-2-0/
'''
# n_ch_exps = [4, 5, 6, 7, 8, 9] #the n-th deep channel's exponent i.e. 2**n 16,32,64,128,256
n_ch_exps = [3,4,5,6,7] #the n-th deep channel's exponent i.e. 2**n 16,32,64,128,256
k_size = (3, 3, 3) #size of filter kernel
k_init = 'he_normal' #kernel initializer
if K.image_data_format() == 'channels_first':
ch_axis = 1
input_shape = (1, TIME, img_width, img_height)
elif K.image_data_format() == 'channels_last':
ch_axis = 4
input_shape = (img_width, img_height, TIME, 1)
inp = Input(shape=input_shape)
encodeds = []
# encoder
enc = inp
print(n_ch_exps)
for l_idx, n_ch in enumerate(n_ch_exps):
enc = Conv3D(filters=2**n_ch, kernel_size=k_size, activation='relu', padding='same', kernel_initializer=k_init)(enc)
enc = Dropout(0.15*l_idx,)(enc)
enc = Conv3D(filters=2**n_ch, kernel_size=k_size, activation='relu', padding='same', kernel_initializer=k_init)(enc)
encodeds.append(enc)
#print(l_idx, enc)
if n_ch < n_ch_exps[-1]: #do not run max pooling on the last encoding/downsampling step
enc = MaxPooling3D(pool_size=(2,2,1))(enc)
# decoder
dec = enc
print(n_ch_exps[::-1][1:])
decoder_n_chs = n_ch_exps[::-1][1:]
for l_idx, n_ch in enumerate(decoder_n_chs):
l_idx_rev = len(n_ch_exps) - l_idx - 2 #
dec = Conv3DTranspose(filters=2**n_ch, kernel_size=k_size, strides=(2,2,1), activation='relu', padding='same', kernel_initializer=k_init)(dec)
dec = concatenate([dec, encodeds[l_idx_rev]], axis=ch_axis)
dec = Conv3D(filters=2**n_ch, kernel_size=k_size, activation='relu', padding='same', kernel_initializer=k_init)(dec)
dec = Dropout(0.15*l_idx)(dec)
dec = Conv3D(filters=2**n_ch, kernel_size=k_size, activation='relu', padding='same', kernel_initializer=k_init)(dec)
outp = Conv3DTranspose(filters=1, kernel_size=k_size, activation='sigmoid', padding='same', kernel_initializer='glorot_normal')(dec)
model = Model(inputs=[inp], outputs=[outp])
return model
def decoder_model():
model = Sequential()
# 10x32x32
model.add(
Conv3DTranspose(filters=64,
kernel_size=(3, 5, 5),
padding='same',
strides=(1, 1, 1),
input_shape=(10, 16, 16, 128)))
model.add(TimeDistributed(BatchNormalization()))
# model.add(TimeDistributed(Activation('relu')))
model.add(TimeDistributed(LeakyReLU(alpha=0.2)))
model.add(TimeDistributed(Dropout(0.5)))
# 10x64x64
model.add(
Conv3DTranspose(filters=128,
kernel_size=(3, 5, 5),
padding='same',
strides=(1, 2, 2)))
model.add(TimeDistributed(BatchNormalization()))
# model.add(TimeDistributed(Activation('relu')))
model.add(TimeDistributed(LeakyReLU(alpha=0.2)))
model.add(TimeDistributed(Dropout(0.5)))
# 10x64x64
model.add(
Conv3DTranspose(filters=64,
kernel_size=(3, 5, 5),
padding='same',
strides=(1, 2, 2)))
model.add(TimeDistributed(BatchNormalization()))
# model.add(TimeDistributed(Activation('relu')))
model.add(TimeDistributed(LeakyReLU(alpha=0.2)))
model.add(TimeDistributed(Dropout(0.5)))
# 10x128x128
model.add(
Conv3DTranspose(filters=1,
kernel_size=(3, 5, 5),
strides=(1, 1, 1),
padding='same'))
model.add(TimeDistributed(BatchNormalization()))
model.add(TimeDistributed(Activation('tanh')))
model.add(TimeDistributed(Dropout(0.5)))
return model
def myUpConv3DBlock(input_tensor, filters, kernel_size, strides,
kernel_initializer, padding, block_name,
kernel_regularizer, use_batch_norm, dropout_rate):
"""
3D transpose convolution block exploiting Keras.
This function returns a "black box" containing potentially an up conv. layer, a BN layer
and a dropout layer. The scheme is:
... -> Transpose Conv 3D -> Activation -> BatchNorm -> Dropout -> ...
"""
# NOTES:
# 1. activation is by default "None" in Conv3DTranspose;
output_tensor = Conv3DTranspose(
filters=filters,
kernel_size=kernel_size,
strides=strides,
kernel_initializer=kernel_initializer,
padding=padding,
name=block_name,
kernel_regularizer=kernel_regularizer)(input_tensor)
if use_batch_norm:
output_tensor = BatchNormalization(name=block_name +
'_bn')(output_tensor)
if dropout_rate > 0.0:
output_tensor = Dropout(rate=dropout_rate,
name=block_name + '_dr')(output_tensor)
return output_tensor
def create_convolution_block_up(input_layer,skip_conn, n_filters, batch_normalization=True, kernel_size=(4, 4, 4), activation='relu',
padding='same', strides=(2, 2, 2), instance_normalization=False, dropout=True):
# 3DConv + Normalization + Activation
# Instance Normalization is said to perform better than Batch Normalization
init = RandomNormal(mean=0.0, stddev=0.02) # new
layer = Conv3DTranspose(n_filters, kernel_size, padding=padding, kernel_initializer=init, strides=strides)(input_layer)
if batch_normalization:
layer = BatchNormalization(axis=4)(layer) # channel_last convention
# elif instance_normalization:
elif instance_normalization:
try:
from keras_contrib.layers.normalization.instancenormalization import InstanceNormalization
except ImportError:
raise ImportError("Install keras_contrib in order to use instance normalization."
"\nTry: pip install git+https://www.github.com/farizrahman4u/keras-contrib.git")
layer = InstanceNormalization(axis=4)(layer)
if dropout:
layer = SpatialDropout3D(rate=0.5)(layer)
layer = concatenate([layer, skip_conn], axis=4)
layer = Activation(activation)(layer)
return layer
def f(input):
if is_first_block_of_first_layer:
# don't repeat bn->relu since we just did bn->relu->maxpool
if deconv:
conv_1_1 = Conv3DTranspose(
filters=filters,
kernel_size=(1, 1, 1),
strides=strides,
padding="same",
kernel_initializer="he_normal",
kernel_regularizer=kernel_regularizer)(input)
else:
conv_1_1 = Conv3D(filters=filters,
kernel_size=(1, 1, 1),
strides=strides,
padding="same",
kernel_initializer="he_normal",
kernel_regularizer=kernel_regularizer)(input)
else:
conv_1_1 = _bn_relu_conv3d(
filters=filters,
kernel_size=(1, 1, 1),
strides=strides,
kernel_regularizer=kernel_regularizer)(input)
conv_3_3 = _bn_relu_conv3d(
filters=filters,
kernel_size=(3, 3, 3),
kernel_regularizer=kernel_regularizer)(conv_1_1)
residual = _bn_relu_conv3d(
filters=filters * 4,
kernel_size=(1, 1, 1),
kernel_regularizer=kernel_regularizer)(conv_3_3)
return _shortcut3d(input, residual)
def __transition_up_block(ip,
nb_filters,
type='deconv',
weight_decay=1E-4,
block_prefix=None):
'''Adds an upsampling block. Upsampling operation relies on the the type parameter.
# Arguments
ip: input keras tensor
nb_filters: integer, the dimensionality of the output space
(i.e. the number output of filters in the convolution)
type: can be 'upsampling', 'subpixel', 'deconv'. Determines
type of upsampling performed
weight_decay: weight decay factor
block_prefix: str, for block unique naming
# Input shape
4D tensor with shape:
`(samples, channels, rows, cols)` if data_format='channels_first'
or 4D tensor with shape:
`(samples, rows, cols, channels)` if data_format='channels_last'.
# Output shape
4D tensor with shape:
`(samples, nb_filter, rows * 2, cols * 2)` if data_format='channels_first'
or 4D tensor with shape:
`(samples, rows * 2, cols * 2, nb_filter)` if data_format='channels_last'.
# Returns
a keras tensor
'''
with K.name_scope('TransitionUp'):
if type == 'upsampling':
x = UpSampling3D(
name=name_or_none(block_prefix, '_upsampling'))(ip)
elif type == 'subpixel':
x = Conv3D(nb_filters, (3, 3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(weight_decay),
use_bias=False,
kernel_initializer='he_normal',
name=name_or_none(block_prefix, '_Conv3D'))(ip)
x = SubPixelUpscaling(scale_factor=2,
name=name_or_none(block_prefix,
'_subpixel'))(x)
x = Conv3D(nb_filters, (3, 3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(weight_decay),
use_bias=False,
kernel_initializer='he_normal',
name=name_or_none(block_prefix, '_Conv3D'))(x)
else:
x = Conv3DTranspose(nb_filters, (3, 3, 3),
activation='relu',
padding='same',
strides=(2, 2, 2),
kernel_initializer='he_normal',
kernel_regularizer=l2(weight_decay),
name=name_or_none(block_prefix,
'_Conv3DT'))(ip)
return x
def _shortcut3d(input, residual, deconv=False):
"""3D shortcut to match input and residual and merges them with "sum"."""
if deconv:
stride_dim1 = math.floor(residual._keras_shape[DIM1_AXIS] /
input._keras_shape[DIM1_AXIS])
stride_dim2 = math.floor(residual._keras_shape[DIM2_AXIS] /
input._keras_shape[DIM2_AXIS])
stride_dim3 = math.floor(residual._keras_shape[DIM3_AXIS] /
input._keras_shape[DIM3_AXIS])
padding_dim1 = (
residual._keras_shape[DIM1_AXIS]) % input._keras_shape[DIM1_AXIS]
padding_dim2 = (
residual._keras_shape[DIM2_AXIS]) % input._keras_shape[DIM2_AXIS]
padding_dim3 = (
residual._keras_shape[DIM3_AXIS]) % input._keras_shape[DIM3_AXIS]
padding_dim1 = (math.floor(0.5 * padding_dim1),
math.ceil(0.5 * padding_dim1))
padding_dim2 = (math.floor(0.5 * padding_dim2),
math.ceil(0.5 * padding_dim2))
padding_dim3 = (math.floor(0.5 * padding_dim3),
math.ceil(0.5 * padding_dim3))
else:
stride_dim1 = math.ceil(input._keras_shape[DIM1_AXIS] /
residual._keras_shape[DIM1_AXIS])
stride_dim2 = math.ceil(input._keras_shape[DIM2_AXIS] /
residual._keras_shape[DIM2_AXIS])
stride_dim3 = math.ceil(input._keras_shape[DIM3_AXIS] /
residual._keras_shape[DIM3_AXIS])
equal_channels = residual._keras_shape[CHANNEL_AXIS] == input._keras_shape[
CHANNEL_AXIS]
shortcut = input
if stride_dim1 > 1 or stride_dim2 > 1 or stride_dim3 > 1 \
or not equal_channels:
if deconv: #output = stride_dim * input_dim + padding_dim
shortcut = Conv3DTranspose(
filters=residual._keras_shape[CHANNEL_AXIS],
kernel_size=(1, 1, 1),
strides=(stride_dim1, stride_dim2, stride_dim3),
kernel_initializer="he_normal",
padding="valid",
kernel_regularizer=l2(1e-4))(input)
shortcut = ZeroPadding3D(padding=(padding_dim1, padding_dim2,
padding_dim3))(shortcut)
else:
shortcut = Conv3D(filters=residual._keras_shape[CHANNEL_AXIS],
kernel_size=(1, 1, 1),
strides=(stride_dim1, stride_dim2, stride_dim3),
kernel_initializer="he_normal",
padding="valid",
kernel_regularizer=l2(1e-4))(input)
return add([shortcut, residual])
def get_deconv_layer(dimension, input, num_filters) :
strides = (2, 2) if dimension == 2 else (2, 2, 2)
kernel_size = (2, 2) if dimension == 2 else (2, 2, 2)
if dimension == 2:
return Conv2DTranspose(num_filters, kernel_size=kernel_size, strides=strides)(input)
else :
return Conv3DTranspose(num_filters, kernel_size=kernel_size, strides=strides)(input)
def ConvolutionTranspose(ndim=2, *args, **kwargs):
layer = None
if ndim==2:
layer = Conv2DTranspose(*args, **kwargs)
elif ndim==3:
layer = Conv3DTranspose(*args, **kwargs)
else:
raise ValueError("ndim must be 2 or 3")
return layer
def decoder_model():
inputs = Input(shape=(10, 16, 16, 32))
# 10x32x32
conv_1 = Conv3DTranspose(filters=64,
kernel_size=(3, 5, 5),
padding='same',
strides=(1, 1, 1),
input_shape=(10, 16, 16, 32))(inputs)
x = TimeDistributed(BatchNormalization())(conv_1)
x = TimeDistributed(LeakyReLU(alpha=0.2))(x)
x = TimeDistributed(Dropout(0.5))(x)
# 10x64x64
conv_2 = Conv3DTranspose(filters=128,
kernel_size=(3, 5, 5),
padding='same',
strides=(1, 2, 2))(x)
x = TimeDistributed(BatchNormalization())(conv_2)
x = TimeDistributed(LeakyReLU(alpha=0.2))(x)
x = TimeDistributed(Dropout(0.5))(x)
# 10x64x64
conv_3 = Conv3DTranspose(filters=64,
kernel_size=(3, 5, 5),
padding='same',
strides=(1, 2, 2))(x)
x = TimeDistributed(BatchNormalization())(conv_3)
x = TimeDistributed(LeakyReLU(alpha=0.2))(x)
x = TimeDistributed(Dropout(0.5))(x)
# 10x128x128
conv_4 = Conv3DTranspose(filters=3,
kernel_size=(3, 11, 11),
strides=(2, 2, 2),
padding='same')(x)
x = TimeDistributed(BatchNormalization())(conv_4)
x = TimeDistributed(Activation('tanh'))(x)
predictions = TimeDistributed(Dropout(0.5))(x)
model = Model(inputs=inputs, outputs=predictions)
return model
def transpose_block(input_tensor, skip_tensor, n_filters, kernel_size=3, strides=1):
# A wrapper of the Keras Conv3DTranspose block to serve as a building block for upsampling layers
shape_x = K.int_shape(input_tensor)
shape_xskip = K.int_shape(skip_tensor)
conv = Conv3DTranspose(filters=n_filters, kernel_size=kernel_size, padding='same', strides=(shape_xskip[1] // shape_x[1], shape_xskip[2] // shape_x[2], shape_xskip[3] // shape_x[3]), kernel_initializer="he_normal")(input_tensor)
act = LeakyReLU(alpha=alpha)(conv)
output = Concatenate(axis=4)([act, skip_tensor])
return output
def unet_block_expand(block_input, numFts, concat_block, conv_kernel):
# Defining a UNET block in the feature upsampling path
up = Conv3DTranspose(numFts, (3, 3, 3), strides=(2, 2, 1),
padding='same')(block_input)
up = concatenate([up, concat_block], axis=4)
up = Conv3D(numFts, conv_kernel, padding='same')(up)
up = BatchNormalization()(up)
up = Activation('relu')(up)
up = Conv3D(numFts, conv_kernel, padding='same')(up)
up = BatchNormalization()(up)
up = Activation('relu')(up)
return up
def level_block(m, dim, depth, inc, acti, do, bn, mp, up, res):
if depth > 0:
n = conv_block(m, dim, acti, bn, res,do=0)
m = MaxPooling3D(pool_size=(2,2,2))(n) if mp else Conv3D(dim, 3, strides=2, padding='same')(n)
m = level_block(m, int(inc*dim), depth-1, inc, acti, do, bn, mp, up, res)
if up:
m = UpSampling3D(size=(2,2,2))(m)
m = Conv3D(dim, 2, activation=acti, padding='same')(m)
else:
m = Conv3DTranspose(dim, 3, strides=2, activation=acti, padding='same')(m)
n = Concatenate()([n, m])
m = conv_block(n, dim, acti, bn, res,do=0)
else:
m = conv_block(m, dim, acti, bn, res, do=0.5)
return m
def build_generator(img_shape, gf):
"""U-Net Generator"""
def conv3d(layer_input, filters, f_size=(4,4,4), bn=True):
d = create_convolution_block(input_layer=layer_input, n_filters=filters,
batch_normalization=bn, strides=(2, 2, 2), kernel_size=f_size)
return d
def deconv3d(layer_input, skip_input, filters, f_size=(4,4,4),drop=True):
"""Layers used during upsampling"""
u = create_convolution_block_up(input_layer=layer_input,skip_conn=skip_input, n_filters=filters,
batch_normalization=True, strides=(2, 2, 2), kernel_size=f_size, dropout=drop)
return u
# Image input
d0 = Input(batch_shape=img_shape)
# Downsampling
e1 = conv3d(d0, gf, bn=False) # 64
e2 = conv3d(e1, gf * 2) # 128
e3 = conv3d(e2, gf * 4) # 256
e4 = conv3d(e3, gf * 8) # 512
e5 = conv3d(e4, gf * 8) # 512
# bottleneck
e6 = bottleneck(e5, gf * 8, batch_normalization=False, kernel_size=(4, 4, 4), activation='relu',
padding='same', strides=(2, 2, 2), instance_normalization=False) # 512
# Upsampling
u1 = deconv3d(e6, e5, gf * 8, drop=True)
u2 = deconv3d(u1, e4, gf * 8, drop=True)
u3 = deconv3d(u2, e3, gf * 4, drop=True)
u4 = deconv3d(u3, e2, gf * 2, drop=False)
u5 = deconv3d(u4, e1, gf, drop=False)
#
#
init = RandomNormal(mean=0.0, stddev=0.02) # new
u6 = Conv3DTranspose(filters=gf, kernel_size=(4,4,4), padding='same', kernel_initializer=init, strides=(2,2,2))(u5)
#
final_convolution = Conv3D(1, (1, 1, 1))(u6)
act = Activation('relu')(final_convolution)
return Model(d0, act)
def f(input):
if deconv:
conv = Conv3DTranspose(
filters=filters,
kernel_size=kernel_size,
strides=strides,
kernel_initializer=kernel_initializer,
padding=padding,
kernel_regularizer=kernel_regularizer)(input)
else:
conv = Conv3D(filters=filters,
kernel_size=kernel_size,
strides=strides,
kernel_initializer=kernel_initializer,
padding=padding,
kernel_regularizer=kernel_regularizer)(input)
return _bn_relu(conv)
def upconvolve(opName,
inputLayer,
outputChannel,
kernelSize,
stride,
targetShape,
stddev=1e-2,
reuse=False,
weights_init='glorot_uniform'):
return Conv3DTranspose(outputChannel,
kernelSize,
strides=stride,
padding='same',
activation='linear',
use_bias=False,
name=opName,
kernel_initializer=weights_init)(inputLayer)
def myConvTranspose(nf,
n_dims,
prefix=None,
suffix=None,
ks=3,
strides=1,
kernel_initializer=None,
bias_initializer=None):
if kernel_initializer is None:
kernel_initializer = 'glorot_uniform' # keras default for conv kernels
if bias_initializer is None:
bias_initializer = 'zeros' # default for keras conv
# wrapper for 2D and 3D conv
if n_dims == 2:
if not isinstance(strides, tuple):
strides = (strides, strides)
return Conv2DTranspose(
nf,
kernel_size=ks,
padding='same',
strides=strides,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer,
name='_'.join([
str(part)
for part in [prefix, 'conv2Dtrans', suffix
] # include prefix and suffix if they exist
if part is not None and len(str(part)) > 0
]))
elif n_dims == 3:
if not isinstance(strides, tuple):
strides = (strides, strides, strides)
return Conv3DTranspose(
nf,
kernel_size=ks,
padding='same',
strides=strides,
kernel_initializer=kernel_initializer,
bias_initializer=bias_initializer,
name='_'.join([
str(part)
for part in [prefix, 'conv3Dtrans', suffix
] # include prefix and suffix if they exist
if part is not None and len(str(part)) > 0
]))
def f(input):
activation = _bn_relu(input)
if deconv:
return Conv3DTranspose(
filters=filters,
kernel_size=kernel_size,
strides=strides,
kernel_initializer=kernel_initializer,
padding=padding,
kernel_regularizer=kernel_regularizer)(activation)
else:
return Conv3D(filters=filters,
kernel_size=kernel_size,
strides=strides,
kernel_initializer=kernel_initializer,
padding=padding,
kernel_regularizer=kernel_regularizer)(activation)
def conv_block_decode(block_input,
numFt1,
numFt2,
concat_block,
conv_kernel,
strides=(2, 2, 1)):
# Defining a Convolutional block in the decoding path of UNET
up = Conv3DTranspose(numFt1, (3, 3, 3), strides=strides,
padding='same')(block_input)
up = concatenate([up, concat_block], axis=4)
up = Conv3D(numFt1, conv_kernel, padding='same')(up)
up = BatchNormalization()(up)
up = Activation('relu')(up)
up = Conv3D(numFt1, conv_kernel, padding='same')(up)
up = BatchNormalization()(up)
up = Activation('relu')(up)
up = Dropout(0.5)(up)
up = Conv3D(numFt2, conv_kernel, padding='same')(up)
up = BatchNormalization()(up)
up = Activation('relu')(up)
up = Conv3D(numFt2, conv_kernel, padding='same')(up)
up = BatchNormalization()(up)
up = Activation('relu')(up)
return up
def unet_3d(shape, n_filters):
# Convolutional block: Conv3x3 -> BN -> ReLU
def conv_block(inputs,
n_filters,
kernel_size=(3, 3, 3),
activation='relu',
batch_norm=True,
padding='same'):
x = Conv3D(filters=n_filters, kernel_size=kernel_size,
padding=padding)(inputs)
if batch_norm:
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv3D(filters=n_filters, kernel_size=kernel_size,
padding=padding)(x)
if batch_norm:
x = BatchNormalization()(x)
x = Activation('relu')(x)
return x
inputs = Input((*shape, 1))
padded = pad_to_fit(inputs)
# Contracting path
conv1 = conv_block(padded, n_filters)
pool1 = MaxPooling3D(pool_size=(2, 2, 2))(conv1)
conv2 = conv_block(pool1, n_filters * 2)
pool2 = MaxPooling3D(pool_size=(2, 2, 2))(conv2)
conv3 = conv_block(pool2, n_filters * 4)
pool3 = MaxPooling3D(pool_size=(2, 2, 2))(conv3)
conv4 = conv_block(pool3, n_filters * 8)
pool4 = MaxPooling3D(pool_size=(2, 2, 2))(conv4)
# Bridge
conv5 = conv_block(pool4, n_filters * 16)
# Expansive path
up6 = Conv3DTranspose(filters=n_filters * 8,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
padding='same')(conv5)
up6 = concatenate([up6, conv4])
conv6 = conv_block(up6, n_filters * 8)
up7 = Conv3DTranspose(filters=n_filters * 4,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
padding='same')(conv6)
up7 = concatenate([up7, conv3])
conv7 = conv_block(up7, n_filters * 4)
up8 = Conv3DTranspose(filters=n_filters * 2,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
padding='same')(conv7)
up8 = concatenate([up8, conv2])
conv8 = conv_block(up8, n_filters * 2)
up9 = Conv3DTranspose(filters=n_filters,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
padding='same')(conv8)
up9 = concatenate([up9, conv1])
conv9 = conv_block(up9, n_filters)
outputs = Conv3D(filters=1, kernel_size=(1, 1, 1),
activation='sigmoid')(conv9)
outputs = crop_to_fit(inputs, outputs)
model = Model(inputs=[inputs], outputs=[outputs])
return model
def deconv3D_layer_bn(l0, name=None, filters=32, kernel_size=(2,2,2), strides=(2,2,2), padding='same', activation='relu',
kernel_initializer="he_normal"):
l = Conv3DTranspose( filters=filters, name=name, kernel_size=kernel_size, strides=strides, padding=padding,
activation=activation, kernel_initializer=kernel_initializer)(l0)
l = BatchNormalization()(l)
return l
def build(input_shape, num_outputs, block_fn, reg_factor):
"""Instantiate a VoxResNet keras model.
# Arguments
input_shape: Tuple of input shape in the format
(conv_dim1, conv_dim2, conv_dim3, channels) if dim_ordering='tf'
(filter, conv_dim1, conv_dim2, conv_dim3) if dim_ordering='th'
num_outputs: The number of outputs at the final softmax layer
block_fn: Unit block to use {'basic_block', 'bottlenack_block'}
repetitions: Repetitions of unit blocks
# Returns
model: a 3D ResNet model that takes a 5D tensor (volumetric images
in batch) as input and returns a 1D vector (prediction) as output.
"""
get_custom_objects().update(
{'argmax_activation': Activation(custom_activation)})
_handle_data_format()
if len(input_shape) != 4:
raise ValueError("Input shape should be a tuple "
"(conv_dim1, conv_dim2, conv_dim3, channels) "
"for tensorflow as backend or "
"(channels, conv_dim1, conv_dim2, conv_dim3) "
"for theano as backend")
block_fn = _get_block(block_fn)
v_input = Input(shape=input_shape)
# conv1
conv1a = _conv_bn_relu3D(filters=32,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
kernel_regularizer=l2(reg_factor))(v_input)
conv1b = _conv_bn_relu3D(filters=32,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
kernel_regularizer=l2(reg_factor))(conv1a)
# C1
C1d = Conv3DTranspose(filters=32,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
kernel_regularizer=l2(reg_factor),
padding='same')(conv1b)
C1 = Conv3D(filters=32,
kernel_size=(1, 1, 1),
strides=(1, 1, 1),
padding='same',
kernel_regularizer=l2(reg_factor))(C1d)
conv1c = Conv3D(filters=64,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
kernel_regularizer=l2(reg_factor),
padding='same')(conv1b)
# voxres block2-3
filters = 64
block23 = _residual_block3d(block_fn,
filters=filters,
kernel_regularizer=l2(reg_factor),
repetitions=2,
is_first_layer=False)(conv1c)
# C2
C2d = Conv3DTranspose(filters=filters,
kernel_size=(3, 3, 3),
strides=(2, 2, 2),
kernel_regularizer=l2(reg_factor),
padding='same')(block23)
C2 = Conv3D(filters=filters,
kernel_size=(1, 1, 1),
strides=(1, 1, 1),
padding='same',
kernel_regularizer=l2(reg_factor))(C2d)
# concatenation and segmentation
C = Concatenate(axis=-1)([C1, C2])
C = Conv3D(filters=num_outputs,
kernel_size=(1, 1, 1),
strides=(1, 1, 1),
padding='same',
kernel_regularizer=l2(reg_factor))(C)
# F = Reshape((input_shape[0]*input_shape[1]*input_shape[2]*num_outputs,))(C)
C = Activation('softmax')(C)
# C = Lambda(custom_activation, output_shape = (input_shape[0],input_shape[1],input_shape[2],1))(C)
model = Model(inputs=v_input, outputs=C)
return model
def create_model(self):
print("Build U-Net model")
# Build U-Net model
inputs = Input((self.IMG_SIZE, self.IMG_SIZE, self.IMG_SIZE, 1))
s = Lambda(lambda x: x / 255)(inputs)
c1 = Conv3D(8, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(s)
c1 = Dropout(0.1)(c1)
c1 = Conv3D(8, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c1)
p1 = MaxPooling3D((2, 2, 2))(c1)
c2 = Conv3D(32, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p1)
c2 = Dropout(0.1)(c2)
c2 = Conv3D(32, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c2)
p2 = MaxPooling3D((2, 2, 2))(c2)
c3 = Conv3D(64, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p2)
c3 = Dropout(0.2)(c3)
c3 = Conv3D(64, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c3)
p3 = MaxPooling3D((2, 2, 2))(c3)
c4 = Conv3D(128, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p3)
c4 = Dropout(0.2)(c4)
c4 = Conv3D(128, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c4)
p4 = MaxPooling3D(pool_size=(2, 2, 2))(c4)
c5 = Conv3D(256, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(p4)
c5 = Dropout(0.3)(c5)
c5 = Conv3D(256, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c5)
u6 = Conv3DTranspose(128, (2, 2, 2), strides=(2, 2, 2),
padding='same')(c5)
u6 = concatenate([u6, c4])
c6 = Conv3D(128, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(u6)
c6 = Dropout(0.2)(c6)
c6 = Conv3D(128, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c6)
u7 = Conv3DTranspose(64, (2, 2, 2), strides=(2, 2, 2),
padding='same')(c6)
u7 = concatenate([u7, c3])
c7 = Conv3D(64, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(u7)
c7 = Dropout(0.2)(c7)
c7 = Conv3D(64, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c7)
u8 = Conv3DTranspose(32, (2, 2, 2), strides=(2, 2, 2),
padding='same')(c7)
u8 = concatenate([u8, c2])
c8 = Conv3D(32, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(u8)
c8 = Dropout(0.1)(c8)
c8 = Conv3D(32, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c8)
u9 = Conv3DTranspose(8, (2, 2, 2), strides=(2, 2, 2),
padding='same')(c8)
u9 = concatenate([u9, c1], axis=-1)
c9 = Conv3D(8, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(u9)
c9 = Dropout(0.1)(c9)
c9 = Conv3D(8, (3, 3, 3),
activation='elu',
kernel_initializer='he_normal',
padding='same')(c9)
outputs = Conv3D(self.NUM_CLASSES, (1, 1, 1), activation='softmax')(c9)
self.model = Model(inputs=[inputs], outputs=[outputs])
#self.model.compile(optimizer='adam', loss=iou_coef_loss, metrics=[ iou_coef_loss, dice_coef_loss, "accuracy" ])
self.model.compile(optimizer='adam',
loss="categorical_crossentropy",
metrics=[
iou_coef, dice_coef, iou_coef_loss,
dice_coef_loss, "accuracy"
])
self.model.summary()
def build_generator(self):
#model = Sequential()
#in 96*96*1 (noise) + (96*96*1) + (96*96*1) + (96*96*1) [labels]
#out 96*96*96
noise = Input(shape=(96,96,1))
#x1 = Input(shape=(96,96,1))
x2 = Input(shape=(96,96,1))
x3 = Input(shape=(96,96,1))
# ############### Condition X1 ######################################
# tower_1 = Conv2D(16, (2,2), strides=2, padding='same', activation='relu')(x1)
# tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
# tower_1 = Conv2D(16, (2,2), strides=1, padding='same', activation='relu')(tower_1)
# tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
# tower_1 = Conv2D(32, (2,2), strides=2, padding='same', activation='relu')(tower_1)
# tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
# tower_1 = Conv2D(32, (2,2), strides=1, padding='same', activation='relu')(tower_1)
# tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
# tower_1 = Conv2D(64, (2,2), strides=2, padding='same', activation='relu')(tower_1)
# tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
# tower_1 = Conv2D(64, (2,2), strides=1, padding='same', activation='relu')(tower_1)
# tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
# tower_1 = Conv2D(1, (2,2), strides=2, padding='same', activation='relu')(tower_1)
# tower_1 = Flatten()(tower_1)
# tower_1 = Dense(16)(tower_1)
############ Condition X2 ############################################
tower_2 = Conv2D(16, (2,2), strides=2, padding='same', activation='relu')(x2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(16, (2,2), strides=1, padding='same', activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(32, (2,2), strides=2, padding='same', activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(32, (2,2), strides=1, padding='same', activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(64, (2,2), strides=2, padding='same', activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(64, (2,2), strides=1, padding='same', activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(1, (2,2), strides=2, padding='same', activation='relu')(tower_2)
tower_2 = Flatten()(tower_2)
tower_2 = Dense(24)(tower_2)
########### Condition X3 ##############################################
tower_3 = Conv2D(16, (2,2), strides=2, padding='same', activation='relu')(x3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(16, (2,2), strides=1, padding='same', activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(32, (2,2), strides=2, padding='same', activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(32, (2,2), strides=1, padding='same', activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(64, (2,2), strides=2, padding='same', activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(64, (2,2), strides=1, padding='same', activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(1, (2,2), strides=2, padding='same', activation='relu')(tower_3)
tower_3 = Flatten()(tower_3)
tower_3 = Dense(24)(tower_3)
########### Noise #####################################################
n_tower = Conv2D(16, (2,2), strides=2, padding='same', activation='relu')(noise)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(16, (2,2), strides=1, padding='same', activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(32, (2,2), strides=2, padding='same', activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(32, (2,2), strides=1, padding='same', activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(64, (2,2), strides=2, padding='same', activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(64, (2,2), strides=1, padding='same', activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(1, (2,2), strides=2, padding='same', activation='relu')(n_tower)
n_tower = Flatten()(n_tower)
n_tower = Dense(16)(n_tower)
################### Latent Space (vector of size 48) ###################
model_input = concatenate([n_tower, tower_2, tower_3], axis=-1)
################## Reconstruct 3D image #################################
x = Reshape((4,4,4,1))(model_input)
x = (Conv3DTranspose(64, (7,7,7), strides=3, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(64, (3,3,3), strides=1, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(32, (4,4,4), strides=2, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(32, (3,3,3), strides=1, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(16, (4,4,4), strides=2, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(16, (3,3,3), strides=1, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(16, (4,4,4), strides=2, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(1, (1,1,1), strides=1, padding='same'))(x)
x = (Activation('sigmoid'))(x)
return Model([noise, x2, x3], x)
def Vnet_3d(input_img, n_filters=8, dropout=0.2, batch_norm=True):
#c1 = conv_block(input_img,n_filters,3,batch_norm)
c1 = Conv3D(n_filters,
kernel_size=(5, 5, 5),
strides=(1, 1, 1),
padding='same')(input_img)
#c1 = add([c1,input_img])
c2 = Conv3D(n_filters * 2,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
padding='same')(c1)
c3 = conv_block(c2, n_filters * 2, 5, True)
p3 = Conv3D(n_filters * 4,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
padding='same')(c3)
p3 = Dropout(dropout)(p3)
c4 = conv_block(p3, n_filters * 4, 5, True)
p4 = Conv3D(n_filters * 8,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
padding='same')(c4)
p4 = Dropout(dropout)(p4)
c5 = conv_block(p4, n_filters * 8, 5, True)
p6 = Conv3D(n_filters * 16,
kernel_size=(2, 2, 2),
strides=(2, 2, 2),
padding='same')(c5)
p6 = Dropout(dropout)(p6)
#c6 = conv_block(p5, n_filters*8,5,True)
#p6 = Conv3D(n_filters*16,kernel_size = (2,2,2) , strides = (2,2,2) , padding='same')(c6)
p7 = conv_block(p6, n_filters * 16, 5, True)
u6 = Conv3DTranspose(n_filters * 8, (2, 2, 2),
strides=(2, 2, 2),
padding='same')(p7)
u6 = concatenate([u6, c5])
c7 = conv_block(u6, n_filters * 16, 5, True)
c7 = Dropout(dropout)(c7)
u7 = Conv3DTranspose(n_filters * 4, (2, 2, 2),
strides=(2, 2, 2),
padding='same')(c7)
u8 = concatenate([u7, c4])
c8 = conv_block(u8, n_filters * 8, 5, True)
c8 = Dropout(dropout)(c8)
u9 = Conv3DTranspose(n_filters * 2, (2, 2, 2),
strides=(2, 2, 2),
padding='same')(c8)
u9 = concatenate([u9, c3])
c9 = conv_block(u9, n_filters * 4, 5, True)
c9 = Dropout(dropout)(c9)
u10 = Conv3DTranspose(n_filters, (2, 2, 2),
strides=(2, 2, 2),
padding='same')(c9)
u10 = concatenate([u10, c1])
c10 = Conv3D(n_filters * 2,
kernel_size=(5, 5, 5),
strides=(1, 1, 1),
padding='same')(u10)
c10 = Dropout(dropout)(c10)
c10 = add([c10, u10])
#c9 = conv_block(u9,n_filters,3,batch_norm)
outputs = Conv3D(4, (1, 1, 1), activation='softmax')(c10)
model = Model(inputs=input_img, outputs=outputs)
return model
def build_generator(self):
#model = Sequential()
#in 96x96x1 noise + 96x96x1 + 96x96x1 + 96x96x1 labels
#out 96*96*96
noise = Input(shape=(96, 96, 1))
x1 = Input(shape=(96, 96, 1))
x2 = Input(shape=(96, 96, 1))
x3 = Input(shape=(96, 96, 1))
tower_1 = Conv2D(16, (2, 2),
strides=2,
padding='same',
activation='relu')(x1)
tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
tower_1 = Conv2D(16, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_1)
tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
tower_1 = Conv2D(32, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_1)
tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
tower_1 = Conv2D(32, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_1)
tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
tower_1 = Conv2D(64, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_1)
tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
tower_1 = Conv2D(64, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_1)
tower_1 = (BatchNormalization(momentum=0.9))(tower_1)
tower_1 = Conv2D(1, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_1)
tower_1 = Flatten()(tower_1)
tower_1 = Dense(16)(tower_1)
tower_2 = Conv2D(16, (2, 2),
strides=2,
padding='same',
activation='relu')(x2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(16, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(32, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(32, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(64, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(64, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_2)
tower_2 = (BatchNormalization(momentum=0.9))(tower_2)
tower_2 = Conv2D(1, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_2)
tower_2 = Flatten()(tower_2)
tower_2 = Dense(16)(tower_2)
tower_3 = Conv2D(16, (2, 2),
strides=2,
padding='same',
activation='relu')(x3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(16, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(32, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(32, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(64, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(64, (2, 2),
strides=1,
padding='same',
activation='relu')(tower_3)
tower_3 = (BatchNormalization(momentum=0.9))(tower_3)
tower_3 = Conv2D(1, (2, 2),
strides=2,
padding='same',
activation='relu')(tower_3)
tower_3 = Flatten()(tower_3)
tower_3 = Dense(16)(tower_3)
n_tower = Conv2D(16, (2, 2),
strides=2,
padding='same',
activation='relu')(noise)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(16, (2, 2),
strides=1,
padding='same',
activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(32, (2, 2),
strides=2,
padding='same',
activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(32, (2, 2),
strides=1,
padding='same',
activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(64, (2, 2),
strides=2,
padding='same',
activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(64, (2, 2),
strides=1,
padding='same',
activation='relu')(n_tower)
n_tower = (BatchNormalization(momentum=0.9))(n_tower)
n_tower = Conv2D(1, (2, 2),
strides=2,
padding='same',
activation='relu')(n_tower)
n_tower = Flatten()(n_tower)
n_tower = Dense(16)(n_tower)
model_input = concatenate([n_tower, tower_1, tower_2, tower_3],
axis=-1)
# model_input = Conv2D(16, (2,2), strides=2, padding='same', activation='relu')(merge)
# model_input = BatchNormalization()(model_input)
# model_input = Conv2D(16, (2,2), strides=1, padding='same', activation='relu')(model_input)
# model_input = BatchNormalization()(model_input)
# model_input = Conv2D(32, (2,2), strides=2, padding='same', activation='relu')(model_input)
# model_input = BatchNormalization()(model_input)
# model_input = Conv2D(32, (2,2), strides=1, padding='same', activation='relu')(model_input)
# model_input = BatchNormalization()(model_input)
# #model_input = Conv2D(64, (2,2), strides=2, padding='same', activation='relu')(model_input)
# #model_input = BatchNormalization()(model_input)
# #model_input = Conv2D(64, (2,2), strides=1, padding='same', activation='relu')(model_input)
# #model_input = BatchNormalization()(model_input)
# model_input = Conv2D(1, (2,2), strides=3, padding='same', activation='relu')(model_input)
# model_input = BatchNormalization()(model_input)
# model_input = Flatten()(model_input)
# model_input = Dense(64, activation='relu')(model_input)
x = Reshape((4, 4, 4, 1))(model_input)
x = (Conv3DTranspose(64, (7, 7, 7), strides=3, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
#x = (Dropout(0.4))(x)
x = (Conv3DTranspose(64, (3, 3, 3), strides=1, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
#x = (Dropout(0.4))(x)
x = (Conv3DTranspose(32, (4, 4, 4), strides=2, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(32, (3, 3, 3), strides=1, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(16, (4, 4, 4), strides=2, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(16, (3, 3, 3), strides=1, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(16, (4, 4, 4), strides=2, padding='same'))(x)
x = (BatchNormalization(momentum=0.9))(x)
x = (Activation('relu'))(x)
x = (Conv3DTranspose(1, (1, 1, 1), strides=1, padding='same'))(x)
x = (Activation('sigmoid'))(x)
#label_embedding = Flatten()(Embedding(96*96*3, self.latent_dim)(label))
# hello = Model([noise, label], x)
# plot_model(hello,
# to_file='cGAN_generator.png',
# show_shapes=True)
return Model([noise, x1, x2, x3], x)
def Unet(img_shape, params, path='./'):
# print message at runtime
if (img_shape[0] == 64 and np.size(img_shape) == 3):
print('Create 2D U-Net network with 3 levels...\n')
elif (img_shape[0] == 128 and np.size(img_shape) == 3):
print('Create 2D U-Net network with 4 levels...\n')
elif (img_shape[0] == 64 and np.size(img_shape) == 4):
print('Create 3D U-Net network with 3 levels...\n')
elif (img_shape[0] == 128 and np.size(img_shape) == 4):
print('Create 3D U-Net network with 4 levels...\n')
else:
print('???')
def Conv2D_Layers(prev_layer, kernel_size, nr_filts, layer_name):
# first layer
a = Conv2D(filters=nr_filts,
kernel_size=kernel_size,
padding='same',
kernel_initializer="he_normal",
name='%s_C1' % layer_name)(prev_layer)
a = BatchNormalization(name='%s_BN1' % layer_name)(a)
a = Activation(params['activation'], name='relu_%s_A1' % layer_name)(a)
# second layer
a = Conv2D(filters=nr_filts,
kernel_size=kernel_size,
padding='same',
kernel_initializer="he_normal",
name='%s_C2' % layer_name)(a)
a = BatchNormalization(name='%s_BN2' % layer_name)(a)
a = Activation(params['activation'], name='relu_%s_A2' % layer_name)(a)
return a
def Conv3D_Layers(prev_layer, kernel_size, nr_filts, layer_name):
# first layer
a = Conv3D(filters=nr_filts,
kernel_size=kernel_size,
padding='same',
kernel_initializer="he_normal",
name='%s_C1' % layer_name)(prev_layer)
a = BatchNormalization(name='%s_BN1' % layer_name)(a)
a = Activation(params['activation'], name='relu_%s_A1' % layer_name)(a)
# second layer
a = Conv3D(filters=nr_filts,
kernel_size=kernel_size,
padding='same',
kernel_initializer="he_normal",
name='%s_C2' % layer_name)(a)
a = BatchNormalization(name='%s_BN2' % layer_name)(a)
a = Activation(params['activation'], name='relu_%s_A2' % layer_name)(a)
return a
img_input = Input(shape=img_shape, name='Image')
# U-Net Encoder - upper level
if (np.size(img_shape) == 3):
# 2-D network
e1c = Conv2D_Layers(prev_layer=img_input,
nr_filts=int(params['coarse_dim'] / 16),
kernel_size=params['kernel_size'],
layer_name='E1')
e1 = MaxPooling2D(pool_size=(2, 2), name='E1_P')(e1c)
e1 = Dropout(params['dropout'] * 0.5, name='E1_D2')(e1)
elif (np.size(img_shape) == 4):
# 3-D network
e1c = Conv3D_Layers(prev_layer=img_input,
nr_filts=int(params['coarse_dim'] / 16),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='E1')
e1 = MaxPooling3D(pool_size=(2, 2, 2), name='E1_P')(e1c)
e1 = Dropout(params['dropout'] * 0.5, name='E1_D2')(e1)
# U-Net Encoder - second level
if (np.size(img_shape) == 3):
# 2-D network
e2c = Conv2D_Layers(prev_layer=e1,
nr_filts=int(params['coarse_dim'] / 8),
kernel_size=params['kernel_size'],
layer_name='E2')
e2 = MaxPooling2D(pool_size=(2, 2), name='E2_P')(e2c)
e2 = Dropout(params['dropout'], name='E2_D2')(e2)
elif (np.size(img_shape) == 4):
# 3-D network
e2c = Conv3D_Layers(prev_layer=e1,
nr_filts=int(params['coarse_dim'] / 8),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='E2')
e2 = MaxPooling3D(pool_size=(2, 2, 2), name='E2_P')(e2c)
e2 = Dropout(params['dropout'], name='E2_D2')(e2)
# U-Net Encoder - third level
if (np.size(img_shape) == 3):
# 2-D network
e3c = Conv2D_Layers(prev_layer=e2,
nr_filts=int(params['coarse_dim'] / 4),
kernel_size=params['kernel_size'],
layer_name='E3')
e3 = MaxPooling2D(pool_size=(2, 2), name='E3_P')(e3c)
e3 = Dropout(params['dropout'], name='E3_D2')(e3)
elif (np.size(img_shape) == 4):
# 3-D network
e3c = Conv3D_Layers(prev_layer=e2,
nr_filts=int(params['coarse_dim'] / 4),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='E3')
e3 = MaxPooling3D(pool_size=(2, 2, 2), name='E3_P')(e3c)
e3 = Dropout(params['dropout'], name='E3_D2')(e3)
if (img_shape[0] >= 64 and img_shape[0] < 128):
# U-Net Encoder - bottom level
if (np.size(img_shape) == 3):
# 2-D network
b = Conv2D_Layers(prev_layer=e3,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size']),
layer_name='B')
d3 = Conv2DTranspose(filters=int(params['coarse_dim'] / 4),
kernel_size=(params['kernel_size'],
params['kernel_size']),
strides=(2, 2),
padding='same',
name='D3_DC')(b)
elif (np.size(img_shape) == 4):
# 3-D network
b = Conv3D_Layers(prev_layer=e3,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='B')
d3 = Conv3DTranspose(filters=int(params['coarse_dim'] / 4),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
strides=(2, 2, 2),
padding='same',
name='D3_DC')(b)
elif (img_shape[0] >= 128):
if (np.size(img_shape) == 3):
# 2-D network
# U-Net Encoder - fourth level
e4c = Conv2D_Layers(prev_layer=e3,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=params['kernel_size'],
layer_name='E4')
e4 = MaxPooling2D(pool_size=(2, 2), name='E4_P')(e4c)
e4 = Dropout(params['dropout'], name='E4_D2')(e4)
# U-Net Encoder - bottom level
b = Conv2D_Layers(prev_layer=e4,
nr_filts=params['coarse_dim'],
kernel_size=params['kernel_size'],
layer_name='B')
# U-Net Decoder - fourth level
d4 = Conv2DTranspose(filters=int(params['coarse_dim'] / 2),
kernel_size=params['kernel_size'],
strides=(2, 2),
padding='same',
name='D4_DC')(b)
d4 = concatenate([d4, e4c], name='merge_layer_E4_A2')
d4 = Dropout(params['dropout'], name='D4_D1')(d4)
d4 = Conv2D_Layers(prev_layer=d4,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size']),
layer_name='D4')
# U-Net Decoder - third level
d3 = Conv2DTranspose(filters=int(params['coarse_dim'] / 4),
kernel_size=params['kernel_size'],
strides=(2, 2),
padding='same',
name='D3_DC')(d4)
elif (np.size(img_shape) == 4):
# 3-D network
# U-Net Encoder - fourth level
e4c = Conv3D_Layers(prev_layer=e3,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='E4')
e4 = MaxPooling3D(pool_size=(2, 2, 2), name='E4_P')(e4c)
e4 = Dropout(params['dropout'], name='E4_D2')(e4)
# U-Net Encoder - bottom level
b = Conv3D_Layers(prev_layer=e4,
nr_filts=params['coarse_dim'],
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='B')
# U-Net Decoder - fourth level
d4 = Conv3DTranspose(filters=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
strides=(2, 2, 2),
padding='same',
name='D4_DC')(b)
d4 = concatenate([d4, e4c], name='merge_layer_E4_A2')
d4 = Dropout(params['dropout'], name='D4_D1')(d4)
d4 = Conv3D_Layers(prev_layer=d4,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='D4')
# U-Net Decoder - third level
d3 = Conv3DTranspose(filters=int(params['coarse_dim'] / 4),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
strides=(2, 2, 2),
padding='same',
name='D3_DC')(d4)
else:
print('ERROR: input data have wrong dimension')
# U-Net Decoder - third level (continue)
if (np.size(img_shape) == 3):
# 2-D network
d3 = concatenate([d3, e3c], name='merge_layer_E3_A2')
d3 = Dropout(params['dropout'], name='D3_D1')(d3)
d3 = Conv2D_Layers(prev_layer=d3,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size']),
layer_name='D3')
elif (np.size(img_shape) == 4):
# 3-D network
d3 = concatenate([d3, e3c], name='merge_layer_E3_A2')
d3 = Dropout(params['dropout'], name='D3_D1')(d3)
d3 = Conv3D_Layers(prev_layer=d3,
nr_filts=int(params['coarse_dim'] / 2),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='D3')
# U-Net Decoder - second level
if (np.size(img_shape) == 3):
# 2-D network
d2 = Conv2DTranspose(filters=int(params['coarse_dim'] / 8),
kernel_size=params['kernel_size'],
strides=(2, 2),
padding='same',
name='D2_DC')(d3)
d2 = concatenate([d2, e2c], name='merge_layer_E2_A2')
d2 = Dropout(params['dropout'], name='D2_D1')(d2)
d2 = Conv2D_Layers(prev_layer=d2,
nr_filts=int(params['coarse_dim'] / 4),
kernel_size=(params['kernel_size'],
params['kernel_size']),
layer_name='D2')
elif (np.size(img_shape) == 4):
# 3-D network
d2 = Conv3DTranspose(filters=int(params['coarse_dim'] / 8),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
strides=(2, 2, 2),
padding='same',
name='D2_DC')(d3)
d2 = concatenate([d2, e2c], name='merge_layer_E2_A2')
d2 = Dropout(params['dropout'], name='D2_D1')(d2)
d2 = Conv3D_Layers(prev_layer=d2,
nr_filts=int(params['coarse_dim'] / 4),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='D2')
# U-Net Decoder - upper level
if (np.size(img_shape) == 3):
d1 = Conv2DTranspose(filters=int(params['coarse_dim'] / 16),
kernel_size=params['kernel_size'],
strides=(2, 2),
padding='same',
name='D1_DC')(d2)
d1 = concatenate([d1, e1c], name='merge_layer_E1_A2')
d1 = Dropout(params['dropout'], name='D1_D1')(d1)
d1 = Conv2D_Layers(prev_layer=d1,
nr_filts=int(params['coarse_dim'] / 16),
kernel_size=(params['kernel_size'],
params['kernel_size']),
layer_name='D1')
elif (np.size(img_shape) == 4):
d1 = Conv3DTranspose(filters=int(params['coarse_dim'] / 16),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
strides=(2, 2, 2),
padding='same',
name='D1_DC')(d2)
d1 = concatenate([d1, e1c], name='merge_layer_E1_A2')
d1 = Dropout(params['dropout'], name='D1_D1')(d1)
d1 = Conv3D_Layers(prev_layer=d1,
nr_filts=int(params['coarse_dim'] / 16),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
layer_name='D1')
# Outro Layer
if (np.size(img_shape) == 3):
output_image = Conv2D(filters=int(img_shape[-1]),
kernel_size=params['kernel_size'],
strides=(1, 1),
padding='same',
name='out_C')(d1)
elif (np.size(img_shape) == 4):
output_image = Conv3D(filters=int(img_shape[-1]),
kernel_size=(params['kernel_size'],
params['kernel_size'],
params['kernel_size']),
strides=(1, 1, 1),
padding='same',
name='out_C')(d1)
output_image = Activation("sigmoid", name='sigmoid')(output_image)
model = Model(inputs=[img_input], outputs=[output_image], name='Unet')
plot_model(model,
to_file=path + 'model_visualization.png',
show_shapes=True,
show_layer_names=True)
return model
def fCreateModel_FCN_MultiFM_MultiPath(patchSize,
patchSize_down,
dr_rate=0.0,
iPReLU=0,
l1_reg=0,
l2_reg=1e-6):
# Total params: 2,841,098
# The dense layer is repleced by a convolutional layer with filters=2 for the two classes
# The FM from the third down scaled convolutional layer is upsempled by deconvolution and
# added with the FM from the second down scaled convolutional layer.
# The combined FM goes through a convolutional layer with filters=2 for the two classes
# The four predictions from the two pathways are averages as the final result.
Strides = fgetStrides()
kernelnumber = fgetKernelNumber()
sharedConv1 = fCreateVNet_Block
sharedDown1 = fCreateVNet_DownConv_Block
sharedConv2 = fCreateVNet_Block
sharedDown2 = fCreateVNet_DownConv_Block
sharedConv3 = fCreateVNet_Block
sharedDown3 = fCreateVNet_DownConv_Block
inp1 = Input(shape=(1, int(patchSize[0]), int(patchSize[1]),
int(patchSize[2])))
after_1Conv_1 = sharedConv1(inp1,
kernelnumber[0],
type=fgetLayerNumConv(),
l2_reg=l2_reg)
after_1DownConv_1 = sharedDown1(after_1Conv_1,
after_1Conv_1._keras_shape[1],
Strides[0],
iPReLU=iPReLU,
dr_rate=dr_rate,
l2_reg=l2_reg)
after_1Conv_2 = sharedConv2(after_1DownConv_1,
kernelnumber[1],
type=fgetLayerNumConv(),
l2_reg=l2_reg)
after_1DownConv_2 = sharedDown2(after_1Conv_2,
after_1Conv_2._keras_shape[1],
Strides[1],
iPReLU=iPReLU,
dr_rate=dr_rate,
l2_reg=l2_reg)
after_1Conv_3 = sharedConv3(after_1DownConv_2,
kernelnumber[2],
type=fgetLayerNumConv(),
l2_reg=l2_reg)
after_1DownConv_3 = sharedDown3(after_1Conv_3,
after_1Conv_3._keras_shape[1],
Strides[2],
iPReLU=iPReLU,
dr_rate=dr_rate,
l2_reg=l2_reg)
inp2 = Input(shape=(1, int(patchSize_down[0]), int(patchSize_down[1]),
int(patchSize_down[2])))
after_2Conv_1 = sharedConv1(inp2,
kernelnumber[0],
type=fgetLayerNumConv(),
l2_reg=l2_reg)
after_2DownConv_1 = sharedDown1(after_2Conv_1,
after_2Conv_1._keras_shape[1],
Strides[0],
iPReLU=iPReLU,
dr_rate=dr_rate,
l2_reg=l2_reg)
after_2Conv_2 = sharedConv2(after_2DownConv_1,
kernelnumber[1],
type=fgetLayerNumConv(),
l2_reg=l2_reg)
after_2DownConv_2 = sharedDown2(after_2Conv_2,
after_2Conv_2._keras_shape[1],
Strides[1],
iPReLU=iPReLU,
dr_rate=dr_rate,
l2_reg=l2_reg)
after_2Conv_3 = sharedConv3(after_2DownConv_2,
kernelnumber[2],
type=fgetLayerNumConv(),
l2_reg=l2_reg)
after_2DownConv_3 = sharedDown3(after_2Conv_3,
after_2Conv_3._keras_shape[1],
Strides[2],
iPReLU=iPReLU,
dr_rate=dr_rate,
l2_reg=l2_reg)
# fully convolution over the FM from the deepest level
dropout_out1 = Dropout(dr_rate)(after_1DownConv_3)
fclayer1 = Conv3D(
2,
kernel_size=(1, 1, 1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(dropout_out1)
fclayer1 = GlobalAveragePooling3D()(fclayer1)
# Upsample FM from the deepest level, add with FM from level 2,
UpedFM_1Level3 = Conv3DTranspose(filters=97,
kernel_size=(3, 3, 1),
strides=(2, 2, 1),
padding='same')(after_1DownConv_3)
conbined_FM_1Level23 = add([UpedFM_1Level3, after_1DownConv_2])
fclayer2 = Conv3D(
2,
kernel_size=(1, 1, 1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(conbined_FM_1Level23)
fclayer2 = GlobalAveragePooling3D()(fclayer2)
dropout_out2 = Dropout(dr_rate)(after_2DownConv_3)
fclayer3 = Conv3D(
2,
kernel_size=(1, 1, 1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(dropout_out2)
fclayer3 = GlobalAveragePooling3D()(fclayer3)
# Upsample FM from the deepest level, add with FM from level 2,
UpedFM_2Level3 = Conv3DTranspose(filters=97,
kernel_size=(3, 3, 1),
strides=(2, 2, 1),
padding='same')(after_2DownConv_3)
conbined_FM_2Level23 = add([UpedFM_2Level3, after_2DownConv_2])
fclayer4 = Conv3D(
2,
kernel_size=(1, 1, 1),
kernel_initializer='he_normal',
weights=None,
padding='valid',
strides=(1, 1, 1),
kernel_regularizer=l1_l2(l1_reg, l2_reg),
)(conbined_FM_2Level23)
fclayer4 = GlobalAveragePooling3D()(fclayer4)
# combine the two predictions using average
fcl_aver = average([fclayer1, fclayer2, fclayer3, fclayer4])
predict = Activation('softmax')(fcl_aver)
cnn_fcl_2p = Model(inputs=[inp1, inp2], outputs=predict)
return cnn_fcl_2p
