def keras_model(img_width=256, img_height=256):
'''
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
k_size = (3, 3) # size of filter kernel
k_init = 'he_normal' # kernel initializer
if K.image_data_format() == 'channels_first':
ch_axis = 1
input_shape = (3, img_width, img_height)
elif K.image_data_format() == 'channels_last':
ch_axis = 3
input_shape = (img_width, img_height, 3)
inp = Input(shape=input_shape)
encodeds = []
# encoder
enc = inp
print(n_ch_exps)
for l_idx, n_ch in enumerate(n_ch_exps):
enc = Conv2D(filters=2**n_ch,
kernel_size=k_size,
activation='relu',
padding='same',
kernel_initializer=k_init)(enc)
enc = Dropout(0.1 * l_idx, )(enc)
enc = Conv2D(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 = MaxPooling2D(pool_size=(2, 2))(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 = Conv2DTranspose(filters=2**n_ch,
kernel_size=k_size,
strides=(2, 2),
activation='relu',
padding='same',
kernel_initializer=k_init)(dec)
dec = concatenate([dec, encodeds[l_idx_rev]], axis=ch_axis)
dec = Conv2D(filters=2**n_ch,
kernel_size=k_size,
activation='relu',
padding='same',
kernel_initializer=k_init)(dec)
dec = Dropout(0.1 * l_idx)(dec)
dec = Conv2D(filters=2**n_ch,
kernel_size=k_size,
activation='relu',
padding='same',
kernel_initializer=k_init)(dec)
outp = Conv2DTranspose(filters=1,
kernel_size=k_size,
activation='sigmoid',
padding='same',
kernel_initializer='glorot_normal')(dec)
model = Model(inputs=[inp], outputs=[outp])
return model
def CCAE_256(input_shape):
model = Sequential()
pad3 = 'same'
model.add(
Conv2D(64,
5,
strides=2,
padding='same',
activation='relu',
name='conv1',
input_shape=input_shape))
model.add(MaxPooling2D((2, 2), padding="same"))
model.add(BatchNormalization())
model.add(
Conv2D(128,
5,
strides=2,
padding='same',
activation='relu',
name='conv2'))
model.add(MaxPooling2D((2, 2), padding="same"))
model.add(BatchNormalization())
model.add(
Conv2D(256,
3,
strides=2,
padding=pad3,
activation='relu',
name='conv3'))
model.add(Flatten())
model.add(BatchNormalization())
model.add(Dense(units=128, name='embedding'))
model.add(Dense(units=128 * 16, name='dense'))
model.add(BatchNormalization())
model.add(Reshape((4, 4, 128)))
#model.summary()
model.add(
Conv2DTranspose(64,
3,
strides=2,
padding=pad3,
activation='relu',
name='deconv3'))
model.add(UpSampling2D((2, 2)))
model.add(
Conv2DTranspose(32,
5,
strides=2,
padding='same',
activation='relu',
name='deconv2'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2DTranspose(16, 5, strides=2, padding='same',
name='deconv1'))
model.add(
Conv2DTranspose(input_shape[2],
5,
strides=2,
padding='same',
name='deconv_out'))
#model.summary()
return model
def build_generator(self):
model = Sequential()
# model.add(Dense(1024, input_dim=self.latent_dim))
# model.add(Reshape((4, 4, -1)))
# model.add(Conv2DTranspose(128, 8, data_format="channels_last"))
# model.add(BatchNormalization())
# model.add(LeakyReLU(alpha=0.2))
# model.add(Dropout(rate=0.3))
# model.add(Conv2DTranspose(128, 8, data_format="channels_last"))
# model.add(BatchNormalization())
# model.add(LeakyReLU(alpha=0.2))
# model.add(Dropout(rate=0.3))
# model.add(Conv2DTranspose(128, 8, data_format="channels_last"))
# model.add(BatchNormalization())
# model.add(LeakyReLU(alpha=0.2))
# model.add(Dropout(rate=0.3))
# # model.add(Conv2DTranspose(128, 7, data_format="channels_last"))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Dropout(rate=0.3))
# # model.add(Conv2DTranspose(128, 4, data_format="channels_last"))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Dropout(rate=0.3))
# # model.add(Conv2DTranspose(128, 4, data_format="channels_last"))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Dropout(rate=0.3))
# # model.add(Conv2DTranspose(128, 4, data_format="channels_last"))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Dropout(rate=0.3))
# # model.add(Conv2DTranspose(64, 5, data_format="channels_last", padding='same'))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Conv2DTranspose(64, 5, data_format="channels_last", padding='same'))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Conv2DTranspose(64, 5, data_format="channels_last", padding='same'))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Conv2DTranspose(64, 5, data_format="channels_last", padding='same'))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# # model.add(Conv2DTranspose(64, 5, data_format="channels_last", padding='same'))
# # model.add(BatchNormalization())
# # model.add(LeakyReLU(alpha=0.2))
# model.add(Conv2DTranspose(self.num_channels, 4, data_format="channels_last"))
# model.add(BatchNormalization())
# model.add(LeakyReLU(alpha=0.2))
# model.add(Activation('tanh'))
model.add(
Dense(64 * self.img_rows * self.img_cols,
activation="relu",
input_dim=self.latent_dim))
model.add(Reshape((self.img_rows, self.img_cols, 64)))
#model.add(UpSampling2D())
model.add(Conv2DTranspose(64, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
#model.add(Activation("relu"))
model.add(LeakyReLU())
model.add(Dropout(rate=0.3))
#model.add(UpSampling2D())
model.add(Conv2DTranspose(32, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
#model.add(Activation("relu"))
model.add(LeakyReLU())
model.add(Dropout(rate=0.3))
model.add(
Conv2DTranspose(self.num_channels, kernel_size=3, padding="same"))
model.add(Activation("tanh"))
print("Starting Generator layers")
for layer in model.layers:
print(layer.input_shape, layer.output_shape)
print("Ending Generator layers")
model.summary()
noise = Input(shape=(self.latent_dim, ))
label = Input(shape=(1, ), dtype='int32')
label_embedding = Flatten()(Embedding(self.num_classes,
self.latent_dim)(label))
model_input = multiply([noise, label_embedding])
img = model(model_input)
return Model([noise, label], img)
def bottleneck_decoder(self,
tensor,
nfilters,
upsampling=False,
normal=False,
name=''):
"""
:param tensor: input tensor
:param nfilters: number of filters
:param upsampling: Enables Transposed convolution
:param normal: Enables 3x3 convolution on feature map
:param name: The name for the weight variable.
:return: decoder output
"""
y = tensor
skip = tensor
if upsampling:
skip = Conv2D(filters=nfilters,
kernel_size=(1, 1),
kernel_initializer='he_normal',
strides=(1, 1),
padding='same',
use_bias=False,
name=f'1x1_conv_skip_{name}')(skip)
skip = UpSampling2D(size=(2, 2),
name=f'upsample_skip_{name}')(skip)
y = Conv2D(filters=nfilters // 4,
kernel_size=(1, 1),
kernel_initializer='he_normal',
strides=(1, 1),
padding='same',
use_bias=False,
name=f'1x1_conv_{name}')(y)
y = BatchNormalization(momentum=0.1, name=f'bn_1x1_{name}')(y)
y = PReLU(shared_axes=[1, 2], name=f'prelu_1x1_{name}')(y)
if upsampling:
# upsample with learned weights through convolution with a fractional stride
y = Conv2DTranspose(filters=nfilters // 4,
kernel_size=(3, 3),
kernel_initializer='he_normal',
strides=(2, 2),
padding='same',
name=f'3x3_deconv_{name}')(y)
elif normal:
Conv2D(filters=nfilters // 4,
kernel_size=(3, 3),
strides=(1, 1),
kernel_initializer='he_normal',
padding='same',
name=f'3x3_conv_{name}')(y)
y = BatchNormalization(momentum=0.1, name=f'bn_main_{name}')(y)
y = PReLU(shared_axes=[1, 2], name=f'prelu_{name}')(y)
y = Conv2D(filters=nfilters,
kernel_size=(1, 1),
kernel_initializer='he_normal',
use_bias=False,
name=f'final_1x1_{name}')(y)
y = BatchNormalization(momentum=0.1, name=f'bn_final_{name}')(y)
y = Add(name=f'add_{name}')([y, skip])
y = ReLU(name=f'relu_out_{name}')(y)
return y
def build(self):
"""
Build the model for training
"""
print('. . . . .Building VGG. . . . .')
inputs = Input(shape=(self.im_height, self.im_width, 3))
# Block 1
block1_conv1 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv1')(inputs)
block1_conv2 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv2')(block1_conv1)
block1_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block1_pool')(block1_conv2)
# Block 2
block2_conv1 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv1')(block1_pool)
block2_conv2 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv2')(block2_conv1)
block2_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block2_pool')(block2_conv2)
# Block 3
block3_conv1 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv1')(block2_pool)
block3_conv2 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv2')(block3_conv1)
block3_conv3 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv3')(block3_conv2)
block3_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block3_pool')(block3_conv3)
# Block 4
block4_conv1 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv1')(block3_pool)
block4_conv2 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv2')(block4_conv1)
block4_conv3 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv3')(block4_conv2)
block4_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block4_pool')(block4_conv3)
# Block 5
block5_conv1 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv1')(block4_pool)
block5_conv2 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv2')(block5_conv1)
block5_conv3 = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv3')(block5_conv2)
block5_pool = MaxPooling2D((2, 2), strides=(2, 2),
name='block5_pool')(block5_conv3)
pool5_conv1x1 = Conv2D(2, (1, 1), activation='relu',
padding='same')(block5_pool)
upsample_1 = Conv2DTranspose(2,
kernel_size=(4, 4),
strides=(2, 2),
padding="same")(pool5_conv1x1)
pool4_conv1x1 = Conv2D(2, (1, 1), activation='relu',
padding='same')(block4_pool)
add_1 = Add()([upsample_1, pool4_conv1x1])
upsample_2 = Conv2DTranspose(2,
kernel_size=(4, 4),
strides=(2, 2),
padding="same")(add_1)
pool3_conv1x1 = Conv2D(2, (1, 1), activation='relu',
padding='same')(block3_pool)
add_2 = Add()([upsample_2, pool3_conv1x1])
upsample_3 = Conv2DTranspose(2,
kernel_size=(16, 16),
strides=(8, 8),
padding="same")(add_2)
output = Dense(2, activation='softmax')(upsample_3)
model = Model(inputs, output, name='multinet_seg')
print('. . . . .Build Compeleted. . . . .')
return model
def build_vae(input_shape: tuple,
latent_dim: int,
beta: float = 1.0,
enable_mse: bool = False,
enable_graph: bool = False,
verbose: int = 0):
intermediate_dim = 512
original_dim = np.prod(input_shape)
if verbose > 0:
print("input_shape:", input_shape)
if len(input_shape)==1:
# VAE model = encoder + decoder
# build encoder model
inputs = Input(shape=input_shape, name='encoder_input')
x = Dense(intermediate_dim, activation='relu')(inputs)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
# use reparameterization trick to push the sampling out as input
# note that "output_shape" isn't necessary with the TensorFlow backend
z = Lambda(sampling, output_shape=(latent_dim,), name='z')([z_mean, z_log_var])
# instantiate encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()
if enable_graph:
plot_model(encoder, to_file='vae_mlp_encoder.png', show_shapes=True)
# build decoder model
latent_inputs = Input(shape=(latent_dim,), name='z_sampling')
x = Dense(intermediate_dim, activation='relu')(latent_inputs)
outputs = Dense(original_dim, activation='sigmoid')(x)
# instantiate decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
if enable_graph:
plot_model(decoder, to_file='vae_mlp_decoder.png', show_shapes=True)
else:
filters = 2
kernel_size = 5
inputs = Input(shape=input_shape, name='encoder_input')
x = Conv2D(filters=8, kernel_size=kernel_size, activation="relu", strides=2, padding="same")(inputs)
x = Conv2D(filters=16, kernel_size=kernel_size, activation="relu", strides=2, padding="same")(x)
shape = K.int_shape(x)[1:]
x = Flatten()(x)
x = Dense(intermediate_dim, activation='relu')(x)
z_mean = Dense(latent_dim, name='z_mean')(x)
z_log_var = Dense(latent_dim, name='z_log_var')(x)
# use reparameterization trick to push the sampling out as input
# note that "output_shape" isn't necessary with the TensorFlow backend
z = Lambda(sampling, output_shape=(latent_dim,), name='z')([z_mean, z_log_var])
# instantiate encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()
if enable_graph:
plot_model(encoder, to_file='vae_mlp_encoder.png', show_shapes=True)
# build decoder model
latent_inputs = Input(shape=(latent_dim,), name='z_sampling')
x = Dense(np.prod(shape), activation='relu')(latent_inputs)
x = Reshape(shape)(x)
x = Conv2DTranspose(filters=8, kernel_size=kernel_size, activation="relu", strides=2, padding="same")(x)
outputs = Conv2DTranspose(filters=1, kernel_size=kernel_size, activation="sigmoid", strides=2, padding="same")(x)
# instantiate decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
if enable_graph:
plot_model(decoder, to_file='vae_mlp_decoder.png', show_shapes=True)
# instantiate VAE model
outputs = decoder(encoder(inputs)[2])
vae = Model(inputs, outputs, name='vae_mlp')
return vae, encoder, decoder, vae_loss(enable_mse, beta, original_dim, z_mean, z_log_var)
def Nest_Net(img_input, keep_prob=0.5, num_class=1, deep_supervision=True):
nb_filter = [32, 64, 128, 256, 512]
# Handle Dimension Ordering for different backends
global bn_axis
global keep_rate
keep_rate = keep_prob
bn_axis = 3
# if K.image_dim_ordering() == 'tf':
# bn_axis = 3
# img_input = Input(shape=(img_rows, img_cols, color_type), name='main_input')
# else:
# bn_axis = 1
# img_input = Input(shape=(color_type, img_rows, img_cols), name='main_input')
conv1_1 = standard_unit(img_input, stage='11', nb_filter=nb_filter[0])
pool1 = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(conv1_1)
conv2_1 = standard_unit(pool1, stage='21', nb_filter=nb_filter[1])
pool2 = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(conv2_1)
up1_2 = Conv2DTranspose(nb_filter[0], (2, 2),
strides=(2, 2),
name='up12',
padding='same')(conv2_1)
conv1_2 = concatenate([up1_2, conv1_1], name='merge12', axis=bn_axis)
conv1_2 = standard_unit(conv1_2, stage='12', nb_filter=nb_filter[0])
conv3_1 = standard_unit(pool2, stage='31', nb_filter=nb_filter[2])
pool3 = MaxPooling2D((2, 2), strides=(2, 2), name='pool3')(conv3_1)
up2_2 = Conv2DTranspose(nb_filter[1], (2, 2),
strides=(2, 2),
name='up22',
padding='same')(conv3_1)
conv2_2 = concatenate([up2_2, conv2_1], name='merge22', axis=bn_axis)
conv2_2 = standard_unit(conv2_2, stage='22', nb_filter=nb_filter[1])
up1_3 = Conv2DTranspose(nb_filter[0], (2, 2),
strides=(2, 2),
name='up13',
padding='same')(conv2_2)
conv1_3 = concatenate([up1_3, conv1_1, conv1_2],
name='merge13',
axis=bn_axis)
conv1_3 = standard_unit(conv1_3, stage='13', nb_filter=nb_filter[0])
conv4_1 = standard_unit(pool3, stage='41', nb_filter=nb_filter[3])
pool4 = MaxPooling2D((2, 2), strides=(2, 2), name='pool4')(conv4_1)
up3_2 = Conv2DTranspose(nb_filter[2], (2, 2),
strides=(2, 2),
name='up32',
padding='same')(conv4_1)
conv3_2 = concatenate([up3_2, conv3_1], name='merge32', axis=bn_axis)
conv3_2 = standard_unit(conv3_2, stage='32', nb_filter=nb_filter[2])
up2_3 = Conv2DTranspose(nb_filter[1], (2, 2),
strides=(2, 2),
name='up23',
padding='same')(conv3_2)
conv2_3 = concatenate([up2_3, conv2_1, conv2_2],
name='merge23',
axis=bn_axis)
conv2_3 = standard_unit(conv2_3, stage='23', nb_filter=nb_filter[1])
up1_4 = Conv2DTranspose(nb_filter[0], (2, 2),
strides=(2, 2),
name='up14',
padding='same')(conv2_3)
conv1_4 = concatenate([up1_4, conv1_1, conv1_2, conv1_3],
name='merge14',
axis=bn_axis)
conv1_4 = standard_unit(conv1_4, stage='14', nb_filter=nb_filter[0])
conv5_1 = standard_unit(pool4, stage='51', nb_filter=nb_filter[4])
up4_2 = Conv2DTranspose(nb_filter[3], (2, 2),
strides=(2, 2),
name='up42',
padding='same')(conv5_1)
conv4_2 = concatenate([up4_2, conv4_1], name='merge42', axis=bn_axis)
conv4_2 = standard_unit(conv4_2, stage='42', nb_filter=nb_filter[3])
up3_3 = Conv2DTranspose(nb_filter[2], (2, 2),
strides=(2, 2),
name='up33',
padding='same')(conv4_2)
conv3_3 = concatenate([up3_3, conv3_1, conv3_2],
name='merge33',
axis=bn_axis)
conv3_3 = standard_unit(conv3_3, stage='33', nb_filter=nb_filter[2])
up2_4 = Conv2DTranspose(nb_filter[1], (2, 2),
strides=(2, 2),
name='up24',
padding='same')(conv3_3)
conv2_4 = concatenate([up2_4, conv2_1, conv2_2, conv2_3],
name='merge24',
axis=bn_axis)
conv2_4 = standard_unit(conv2_4, stage='24', nb_filter=nb_filter[1])
up1_5 = Conv2DTranspose(nb_filter[0], (2, 2),
strides=(2, 2),
name='up15',
padding='same')(conv2_4)
conv1_5 = concatenate([up1_5, conv1_1, conv1_2, conv1_3, conv1_4],
name='merge15',
axis=bn_axis)
conv1_5 = standard_unit(conv1_5, stage='15', nb_filter=nb_filter[0])
nestnet_output_1 = Conv2D(num_class, (1, 1),
name='output_1',
kernel_initializer='he_normal',
padding='same',
kernel_regularizer=l2(1e-4))(conv1_2)
nestnet_output_2 = Conv2D(num_class, (1, 1),
name='output_2',
kernel_initializer='he_normal',
padding='same',
kernel_regularizer=l2(1e-4))(conv1_3)
nestnet_output_3 = Conv2D(num_class, (1, 1),
name='output_3',
kernel_initializer='he_normal',
padding='same',
kernel_regularizer=l2(1e-4))(conv1_4)
nestnet_output_4 = Conv2D(num_class, (1, 1),
name='output_4',
kernel_initializer='he_normal',
padding='same',
kernel_regularizer=l2(1e-4))(conv1_5)
if deep_supervision:
output = [
nestnet_output_1, nestnet_output_2, nestnet_output_3,
nestnet_output_4
]
# model = Model(input=img_input, output=[nestnet_output_1,
# nestnet_output_2,
# nestnet_output_3,
# nestnet_output_4])
else:
#model = Model(input=img_input, output=[nestnet_output_4])
output = [nestnet_output_4]
return output
def build_model(image_size,
n_classes):
''' NOTE(GP) original description. Unused argument descriptions have been removed
Build a Keras model with SSD architecture, see references.
The model consists of convolutional feature layers and a number of convolutional
predictor layers that take their input from different feature layers.
The model is fully convolutional.
The implementation found here is a smaller version of the original architecture
used in the paper (where the base network consists of a modified VGG-16 extended
by a few convolutional feature layers), but of course it could easily be changed to
an arbitrarily large SSD architecture by following the general design pattern used here.
This implementation has 7 convolutional layers and 4 convolutional predictor
layers that take their input from layers 4, 5, 6, and 7, respectively.
In case you're wondering why this function has so many arguments: All arguments except
the first two (`image_size` and `n_classes`) are only needed so that the anchor box
layers can produce the correct anchor boxes. In case you're training the network, the
parameters passed here must be the same as the ones used to set up `SSDBoxEncoder`.
In case you're loading trained weights, the parameters passed here must be the same
as the ones used to produce the trained weights.
Some of these arguments are explained in more detail in the documentation of the
`SSDBoxEncoder` class.
Note: Requires Keras v2.0 or later. Training currently works only with the
TensorFlow backend (v1.0 or later).
Arguments:
image_size (tuple): The input image size in the format `(height, width, channels)`.
n_classes (int): The number of categories for classification including
the background class (i.e. the number of positive classes +1 for
the background calss).
Returns:
model: The Keras SSD model.
References:
https://arxiv.org/abs/1512.02325v5
'''
# Input image format
img_height, img_width, img_channels = image_size[0], image_size[1], image_size[2]
# Design the actual network
x = Input(shape=(img_height, img_width, img_channels))
normed = Lambda(lambda z: z/127.5 - 1., # Convert input feature range to [-1,1]
output_shape=(img_height, img_width, img_channels),
name='lambda1')(x)
# 400 * 400 * 3
conv1 = Conv2D(16, (5, 5), name='conv1', strides=(1, 1), padding="same")(normed) # 400 * 400
conv1 = BatchNormalization(axis=3, momentum=0.99, name='bn1')(conv1) # Tensorflow uses filter format [filter_height, filter_width, in_channels, out_channels], hence axis = 3
conv1 = ELU(name='elu1')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2), name='pool1')(conv1)
# 200 * 200
conv2 = Conv2D(32, (3, 3), name='conv2', strides=(1, 1), padding="same")(pool1) # 200 * 200
conv2 = BatchNormalization(axis=3, momentum=0.99, name='bn2')(conv2)
conv2 = ELU(name='elu2')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2), name='pool2')(conv2)
# 100 * 100
conv3 = Conv2D(64, (3, 3), name='conv3', strides=(1, 1), padding="same")(pool2) # 100 * 100
conv3 = BatchNormalization(axis=3, momentum=0.99, name='bn3')(conv3)
conv3 = ELU(name='elu3')(conv3)
# LAYER REMOVED FOR TIME BEING
# conv3b = Conv2D(32, (3, 3), name='conv3b', strides=(1, 1), padding="same")(conv3) # 100 * 100
# conv3b = BatchNormalization(axis=3, momentum=0.99, name='bn3b')(conv3b)
# conv3b = ELU(name='elu3b')(conv3b)
pool3 = MaxPooling2D(pool_size=(2, 2), name='pool3')(conv3)
# LAYER REMOVED FOR TIME BEING
# conv4 = Conv2D(64, (3, 3), name='conv4', strides=(1, 1), padding="same")(pool3) # 50*50
# conv4 = BatchNormalization(axis=3, momentum=0.99, name='bn4')(conv4)
# conv4 = ELU(name='elu4')(conv4)
# pool4 = MaxPooling2D(pool_size=(2, 2), name='pool4')(conv4)
# 50 * 50
conv5 = Conv2D(128, (3, 3), name='conv5', strides=(1, 1), padding="same")(pool3) #50*50
conv5 = BatchNormalization(axis=3, momentum=0.99, name='bn5')(conv5)
conv5 = ELU(name='elu5')(conv5)
pool5 = MaxPooling2D(pool_size=(2, 2), name='pool5')(conv5)
# 25 * 25
conv6 = Conv2D(128, (3, 3), name='conv6', strides=(1, 1), padding="valid")(pool5) #25*25
conv6 = BatchNormalization(axis=3, momentum=0.99, name='bn6')(conv6)
conv6 = ELU(name='elu6')(conv6)
pool6 = MaxPooling2D(pool_size=(2, 2), name='pool6')(conv6)
# 12*12
conv6b = Conv2D(128, (3, 3), name='conv6b', strides=(1, 1), padding="same")(pool6) #12*12
conv6b = BatchNormalization(axis=3, momentum=0.99, name='bn6b')(conv6b)
conv6b = ELU(name='elu6b')(conv6b)
pool6b = MaxPooling2D(pool_size=(2, 2), name='pool6b')(conv6b)
# 6*6
# NOTE (GP) These layers upsample the image back to 51*51
deconv1 = Conv2DTranspose(128, (3,3),name='deconv1', strides=(1, 1), padding='same')(pool6b)
deconv1 = BatchNormalization(axis=3, momentum=0.99, name='bndc1')(deconv1)
deconv1 = ELU(name='eludc1')(deconv1)
uppool1 = UpSampling2D(3)(deconv1)
deconv2 = Conv2DTranspose(64, (3,3),name='deconv2', strides=(1, 1), padding='valid')(uppool1)
deconv2 = BatchNormalization(axis=3, momentum=0.99, name='bndc2')(deconv2)
deconv2 = ELU(name='eludc2')(deconv2)
uppool2 = UpSampling2D(3)(deconv2)
# 51 * 51
# NOTE(GP) This final layer produces the softmax predictions of each class in a 51 * 51 area
out = Conv2DTranspose(21, (3,3),name='out', strides=(1, 1), activation='softmax', padding='same')(uppool2)
predictions = out
model = Model(inputs=x, outputs=predictions)
return model
def get_mnist_model(args):
'''
Return: G, D, GAN
'''
'''
Building Generator
'''
init_kernel = tf.random_normal_initializer(mean=0.0, stddev=0.02)
Z_in = Input(shape=(200, ))
x = Dense(1024, activation='relu', kernel_initializer=init_kernel)(Z_in)
x = BatchNormalization()(x)
x = Dense(7 * 7 * 128, activation='relu',
kernel_initializer=init_kernel)(x)
x = BatchNormalization()(x)
x = Reshape((7, 7, 128))(x)
x = Conv2DTranspose(64, (4, 4),
strides=(2, 2),
padding='same',
activation='relu',
kernel_initializer=init_kernel)(x)
x = BatchNormalization()(x)
G_out = Conv2DTranspose(1, (4, 4),
strides=(2, 2),
padding='same',
activation='tanh',
kernel_initializer=init_kernel)(x)
G = Model(Z_in, G_out)
'''
Builiding Discriminator
'''
D_in = Input(shape=(28, 28, 1))
x = Conv2D(64, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=init_kernel)(D_in)
x = LeakyReLU(0.1)(x)
x = Conv2D(64, (4, 4),
strides=(2, 2),
padding='same',
kernel_initializer=init_kernel)(x)
x = LeakyReLU(0.1)(x)
x = Flatten()(x)
x = Dense(1024, kernel_initializer=init_kernel)(x)
x = LeakyReLU(0.1)(x)
D_out = Dense(1, activation='sigmoid', kernel_initializer=init_kernel)(x)
D = Model(D_in, D_out)
dopt = Adam(lr=args.d_lr, beta_1=0.5, beta_2=0.999)
gamma = K.variable([1])
D.compile(loss=D_loss, optimizer=dopt)
'''
Building GAN
'''
set_trainability(D, False)
GAN_in = Input(shape=(200, ))
G_out = G(GAN_in)
GAN_out = D(G_out)
GAN = Model(GAN_in, GAN_out)
gopt = Adam(lr=args.g_lr, beta_1=0.5, beta_2=0.999)
GAN.compile(loss=com_conv(G_out, args.beta, 2), optimizer=gopt)
return G, D, GAN
def runProgram():
k = 4095
img_rows, img_cols = k, 1 #not one hot
# the data, shuffled and split between train and test sets
(x_train, y_train) = load_data("train", "jpeg")
(x_valid, y_valid) = load_data("valid", "jpeg")
(x_test, y_test) = load_data("test", "jpeg")
print('Before reshape:')
print('x_train shape:', x_train.shape)
print('x_valid shape:', x_valid.shape)
print('x_test shape:', x_test.shape)
x_train = np.reshape(x_train, (len(x_train), 4095, 1, 1))
x_valid = np.reshape(x_valid, (len(x_valid), 4095, 1, 1))
x_test = np.reshape(x_test, (len(x_test), 4095, 1, 1))
y_train = np.reshape(y_train, (len(y_train), 4095, 1, 1))
y_valid = np.reshape(y_valid, (len(y_valid), 4095, 1, 1))
y_test = np.reshape(y_test, (len(y_test), 4095, 1, 1))
print('After reshape:')
print('x_train shape:', x_train.shape)
print('x_valid shape:', x_valid.shape)
print('x_test shape:', x_test.shape)
input_shape = (img_rows, img_cols, 1)
# convert class vectors to binary class matrices
print('Shuffling in unison ')
shuffle_in_unison(x_train, y_train)
shuffle_in_unison(x_valid, y_valid)
shuffle_in_unison(x_test, y_test)
#print('y_train shape:', y_train.shape)
#print(y_train.shape[0], 'train labels')
#print(y_test.shape[0], 'test labels')
batch_size = 50
epochs = 20
input_img = Input(
shape=input_shape
) # adapt this if using `channels_first` image data format
x = Conv2D(100, (24, 1), activation='relu')(input_img)
#x = Dropout(0.5)(x)
x = Conv2D(200, (16, 1), activation='relu')(x)
#x = Dropout(0.5)(x)
#x = Conv2D(100, (8, 1), activation='relu')(x)
#x = Dropout(0.5)(x)
#x = Conv2D(300, (3, 1), activation='relu')(x)
#x = Conv2D(64, (4, 1), activation='relu')(x)
#x = Conv2D(64, (4, 1), activation='relu')(x)
#x = Conv2D(64, (4, 1), activation='relu')(x)
#x = Conv2D(64, (4, 1), activation='relu')(x)
encoded = Conv2D(40, (8, 1), activation='relu')(x)
x = Conv2DTranspose(200, (8, 1), activation='relu')(encoded)
#x = Dropout(0.5)(x)
x = Conv2DTranspose(100, (16, 1), activation='relu')(x)
#x = Dropout(0.5)(x)
#x = Conv2DTranspose(200, (8, 1), activation='relu')(x)
#x = Dropout(0.5)(x)
#x = Conv2DTranspose(100, (16, 1), activation='relu')(x)
#x = Conv2DTranspose(64, (4, 1), activation='relu')(x)
#x = Conv2DTranspose(32, (4, 1), activation='relu')(x)
#x = Conv2DTranspose(32, (8, 1), activation='relu')(x)
#x = Conv2DTranspose(320, (16, 1), activation='relu')(x)
decoded = Conv2DTranspose(1, (24, 1), activation='sigmoid')(x)
model = Model(input_img, decoded)
model.compile(loss=negGrowthRateLoss,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
filepath = 'auto_weights_jpeg_10_0p01.h5'
checkpoint = ModelCheckpoint(filepath,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
csv_logger = CSVLogger('auto_losses_jpeg_10_0p01.csv')
plot_model(model, to_file='auto_model_jpeg_10_0p01.png', show_shapes=True)
#Let's train it for 100 epochs:
#model.load_weights('auto_weights_jpeg_11_0p01.h5')
model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_valid, y_valid),
callbacks=[checkpoint, csv_logger])
#optimization algorithm, metrics, and loss functions
#train
#model.fit(x_train, y_train,batch_size=batch_size,epochs=epochs,verbose=1)
model.save('auto_model_jpeg_10_0p01.h5')
model.load_weights(filepath)
predictions = model.predict(x_test, verbose=0)
print(predictions.shape)
model.summary()
p_p_y = np.array([[0.0, 0.0], [0.0, 0.0]])
ct = np.array([0.0, 0.0])
p_p = np.array([0.0, 0.0])
p_y = np.array([0.0, 0.0])
for j in range(0, num_test_examples):
#filename = open("results/res_test_exmpl_"+str(j)+".csv",'w')
for i in range(0, 4095):
#filename.write(str(predictions[j][i])+","+str(y_test[j][i])+","+str(x_test[j][i])+"\n")
#if(y_test[j][i][0][0] != x_test[j][i][0][0]):
#print(str(y_test[j][i][0][0])+" "+str(x_test[j][i][0][0])+" "+str(predictions[j][i][0][0]))
if (y_test[j][i] == 0):
p_p_y[1][0] = p_p_y[1][0] + predictions[j][i][0][0]
#p[1][y_test[j][i]] = p[1][y_test[j][i]]+(1.0-predictions[j][i])
ct[0] = ct[0] + 1.0
else:
p_p_y[1][1] = p_p_y[1][1] + predictions[j][i][0][0]
#p[0][y_test[j][i]] = p[0][y_test[j][i]]+(1.0-predictions[j][i])
ct[1] = ct[1] + 1.0
p_p[1] = p_p[1] + predictions[j][i][0][0]
#filename.close()
p_p_y[1][0] = p_p_y[1][0] / ct[0]
p_p_y[1][1] = p_p_y[1][1] / ct[1]
p_p_y[0][0] = 1.0 - p_p_y[1][0]
p_p_y[0][1] = 1.0 - p_p_y[1][1]
p_p[1] = p_p[1] / (ct[0] + ct[1])
p_p[0] = 1 - p_p[1]
p_y[0] = ct[0] / (ct[0] + ct[1])
p_y[1] = ct[1] / (ct[0] + ct[1])
mut_inf = 0.0
for i in range(0, 2):
for j in range(0, 2):
p_p_y[i][j] = p_p_y[i][j] * p_y[j]
#ct = ct/sum(ct)
#ct_pred = ct_pred/sum(ct_pred)
file = open("auto_results_jpeg_10_0p01.txt", 'w+')
file.write("Joint:\n")
file.write(str(p_p_y))
#print(sum(p_p_y))
file.write("\n Marginal: Predictions:\n")
file.write(str(p_p))
#print(sum(p_p))
file.write("\n Marginal: Labels:\n")
file.write(str(p_y))
'''
for i in range(0,2):
for j in range(0,2):
p[i][j] = p[i][j]*ct[j]
'''
for i in range(0, 2):
for j in range(0, 2):
if (p_p_y[i][j] != 0):
mut_inf = mut_inf + (p_p_y[i][j] * log(
(p_p_y[i][j]) / (p_p[i] * p_y[j])) / log(2.0))
file.write("\nMutual information:\n")
file.write(str(mut_inf))
a, b, c = mngl_arr_test.shape;
mngl_arr_test = np.reshape(mngl_arr_test, [a, b, c, 1]);
input_shape = (100, 100, 1);
filter0 = 8; th_layer0 = 32;
filter1 = 8; th_layer1 = 1;
model = Sequential();
model.add(Conv2D(th_layer0, kernel_size=(filter0,filter0), strides=(1,1), activation='relu',
padding='same', input_shape=input_shape));
model.add(Conv2DTranspose(th_layer1, kernel_size=(filter1,filter1), strides=(1,1), activation='relu',
padding='same', input_shape=input_shape));
#model.compile(loss=losses.mean_squared_error, optimizer=optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-6)) ;
model.compile(loss=losses.mean_squared_error, optimizer=optimizers.adam());
logger = tlg.training_logger();
cPoint = ModelCheckpoint(filepath='./Archive/Toy2.hdf5', verbose=1, save_best_only=True)
eStop = EarlyStopping(monitor='val_loss', min_delta=0.01, patience=8, verbose=1, restore_best_weights=True);
rPlat = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=2, verbose=1, min_lr=0.00001)
model.fit(mngl_arr_train, orig_arr_train,
epochs=5,
batch_size=128,
def _gen_model(self):
"""
Gen the encoder
- save image_shape before dense layers to avoid np.reshape screwing us over again.
Gen the decoder
- Do re parameterization thing first
Combine to make VAE
"""
def sampling(args):
"""Re-parameterization trick of sampling. This allows us to learn mean and variance in network.
args is the previous tensor. So this will be [self.z_mean, self.z_log_var],
where zmean and z-log-var are tensors.
"""
z_mean, z_var = args
epsilon = K.random_normal(shape=(K.shape(z_mean)[0], K.int_shape(z_mean)[1])) # Shape is num_samples, dim
return z_mean + K.exp(z_var / 2) * epsilon
# #-------# ENCODER #-------#
self.input_layer = Input(shape=(28, 28, self.channels), name='input')
x = Conv2D(self.channels * 48, (3, 3), activation='relu', padding='same', strides=2)(self.input_layer)
x = Conv2D(self.channels * 72, (3, 3), activation='relu', padding='same', strides=2)(x)
intermediary_shape = K.int_shape(x)
encoding = Flatten()(x)
encoding = Dense(128, activation='relu')(encoding)
encoding = Dense(128, activation='relu')(encoding)
self.z_mean = Dense(self.encoding_dim)(encoding) # No Activation
self.z_log_var = Dense(self.encoding_dim)(encoding) # No Activation
# do re-parameterization to get our ltent vector
sampled_encoding = Lambda(sampling)([self.z_mean, self.z_log_var])
self.encoding_layer = sampled_encoding
# Save the encoded signal
self.encoder = Model(self.input_layer, [self.z_mean, self.z_log_var, self.encoding_layer])
# self.encoder.summary()
# #-------# DECODER #-------#
decoder_input = Input(shape=(self.encoding_dim,))
x = Dense(128, activation='relu')(decoder_input)
x = Dense(128, activation='relu')(x)
x = Dense(intermediary_shape[1] * intermediary_shape[2] * intermediary_shape[3], activation='relu')(x)
x = Reshape(target_shape=(intermediary_shape[1], intermediary_shape[2], intermediary_shape[3]))(x)
x = Conv2DTranspose(self.channels * 48, (3, 3), activation='relu', padding='same', strides=2)(x)
decoder_output = Conv2DTranspose(self.channels, (3, 3), activation='sigmoid', strides=2, padding='same')(x)
self.decoder = Model(decoder_input, decoder_output)
self.decoder.summary()
self.output_layer = self.decoder(self.encoder(self.input_layer)[-1])
self.auto_encoder = Model(self.input_layer, self.output_layer)
self.auto_encoder.summary()
def kl_reconstruction_loss(y, predicted): # VAE ELBO from lecture
reconstruction_loss = 28 * 28 * self.channels * binary_crossentropy(K.flatten(y), K.flatten(predicted))
kl_loss = - 0.5 * K.sum(1 + self.z_log_var - K.square(self.z_mean) - K.exp(self.z_log_var), axis=-1)
vae_loss = K.mean(reconstruction_loss + kl_loss)
return vae_loss
self.auto_encoder.compile(optimizer='rmsprop', loss=kl_reconstruction_loss)
def vae_model(fname, save=True, save_name=None, verbose=True):
imgs = load(fname)
imgs = np.array(imgs)
x_train, x_test = split_into_test_train(imgs)
img_rows, img_cols, img_chns = 100, 100, 3
if K.image_data_format() == 'channels_first':
original_img_size = (img_chns, img_rows, img_cols)
else:
original_img_size = (img_rows, img_cols, img_chns)
epochs = 50
batch_size = 50
# number of convolutional filters to use
filters = 64
# convolution kernel size
num_conv = 3
latent_dim = 2
intermediate_dim = 128
epsilon_std = 1.0
activation = 'relu'
# input image dimensions
input_shape = (100, 100, 3) #Define shape without including the batch size
#First we create the encoder network which maps inputs to our latent distribution parameters:
x = Input(shape=input_shape)
conv_1 = Conv2D(img_chns,
kernel_size=(2, 2),
padding='same',
activation=activation)(x) #Inputs & outputs a 4D tensor
if verbose:
print(conv_1.shape)
conv_2 = Conv2D(filters,
kernel_size=(2, 2),
padding='same',
activation=activation,
strides=(2, 2))(conv_1)
if verbose:
print(conv_2.shape)
conv_3 = Conv2D(filters,
kernel_size=num_conv,
padding='same',
activation=activation,
strides=1)(conv_2)
if verbose:
print(conv_3.shape)
conv_4 = Conv2D(filters,
kernel_size=num_conv,
padding='same',
activation=activation,
strides=2)(conv_3)
if verbose:
print(conv_4.shape)
flat = Flatten()(conv_4) #For generating the latent vector
if verbose:
print(flat.shape)
hidden = Dense(intermediate_dim, activation=activation)(flat)
if verbose:
print(hidden.shape)
z_mean = Dense(latent_dim)(hidden)
z_log_sigma = Dense(latent_dim)(
hidden
) #Use log variance instead of standard deviation as it is more convenient and helps with numerical stability
#Use the latent distribution parameters to sample new & similar points from the latent space
def sampling(args):
z_mean, z_log_sigma = args
epsilon = K.random_normal(
shape=(K.shape(z_mean)[0], latent_dim),
mean=0.,
stddev=epsilon_std
) #Normally distributed values in a tensor to be used as noise
return z_mean + K.exp(z_log_sigma) * epsilon
#Shifting the random sample by the mean and scaling it by the variance
#Make the sampling the input
z = Lambda(sampling, output_shape=(latent_dim, ))(
[z_mean, z_log_sigma]) #Function, output shape multiplied by args
#Lambda wraps an arbitrary expression as a layer, so here we are wrapping the sampling (latent space) as our input layer
#Map the latent points to reconstructed inputs
decoder_hid = Dense(intermediate_dim, activation=activation)
decoder_upsample = Dense(filters * int(img_rows / 4) * int(img_cols / 4),
activation=activation)
if K.image_data_format() == 'channels_first':
output_shape = (batch_size, filters, int(img_rows / 4),
int(img_cols / 4))
else:
output_shape = (batch_size, int(img_rows / 4), int(img_cols / 4),
filters)
decoder_reshape = Reshape(output_shape[1:]) #Reshapes the output
decoder_deconv_1 = Conv2DTranspose(
filters,
kernel_size=num_conv,
padding='same',
strides=1,
activation=activation) #Transposed layers for deconvolution
decoder_deconv_2 = Conv2DTranspose(filters,
kernel_size=num_conv,
padding='same',
strides=2,
activation=activation)
if K.image_data_format() == 'channels_first':
output_shape = (batch_size, filters, int(img_rows + 1),
int(img_cols + 1))
else:
output_shape = (batch_size, int(img_rows + 1), int(img_cols + 1),
filters)
decoder_deconv_3_upsamp = Conv2DTranspose(filters,
kernel_size=(3, 3),
strides=(2, 2),
padding='valid',
activation=activation)
decoder_mean_squash = Conv2D(img_chns,
kernel_size=2,
padding='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)
#Instantiate 3 models
#End-to-end autoencoder for mapping inputs to reconstructions
vae = Model(x, x_decoded_mean_squash)
kl = kl_loss(z_mean, z_log_sigma)
vae.add_loss(kl)
#Encoder mapping from inputs to latent space
encoder = Model(x, z_mean)
#Generator which takes points from the latent space to output the reconstructed samples
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)
#Push z through decoder
generator = Model(decoder_input, _x_decoded_mean_squash)
#Time to train!
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
print(x_test.shape)
shape = x_train.shape[1:]
#Train using the end-to-end model with a custom loss & K-L divergence regularization
"""def vae_loss(x, x_decoded_mean):
xent_loss = metrics.binary_crossentropy(x, x_decoded_mean_squash) #Reconstruction loss
#Binary crossentropy because the decoding term is a Bernoulli multi layered perceptron - is it worth also trying Gaussian + MSE??
kl_loss = - 0.5 * K.mean(1 + z_log_sigma - K.square(z_mean) - K.exp(z_log_sigma), axis=-1) #Variational loss
return xent_loss + kl_loss #Combine the losses
"""
#Can only get these losses to work when we define them outside of the VAE model
vae.compile(optimizer='adam', loss=reconstruction_loss)
vae.summary()
vae.fit(x_train,
x_train,
shuffle=True,
epochs=epochs,
batch_size=batch_size,
validation_data=(x_test, x_test))
predictions = vae.predict(x_test, batch_size=batch_size)
if save:
save_array((x_test, predictions), save_name + '_imgs_preds')
def infect_seg(input_shape,
num_filters=[32, 64, 64, 128],
padding='same',
dropout=0.2):
"""Generate CN-Net model to train on CT scan images
Arbitrary number of input channels and output classes are supported.
Sizes are noted with 100x100 input images.
Arguments:
input_shape - (? (number of examples),
input image height (pixels),
input image width (pixels),
input image features (1 for grayscale, 3 for RGB))
num_filters - number of filters (exactly 4 should be passed)
padding - 'same' or 'valid'
dropout - fraction of units to dropout, 0 to keep all units
Output:
CN-Net model expecting input shape (height, width, channels) and generates
two outputs with shape (height, width, channels).
"""
assert len(num_filters) == 4
x_input = Input(input_shape)
x, x1 = conv_block_1(x_input,
num_filters[0],
padding=padding,
maxpool2Dsize=(2, 2),
dropout=dropout,
kernel_initializer="he_normal") #x: 50x50
x, x2 = conv_block_1(x,
num_filters[1],
padding=padding,
maxpool2Dsize=(2, 2),
dropout=dropout,
kernel_initializer="he_normal") #x: 25x25
x, _ = conv_block_1(x,
num_filters[2],
padding=padding,
maxpool2Dsize=(1, 1),
dropout=dropout,
kernel_initializer="he_normal") #x: 25x25
x, _ = conv_block_1(x,
num_filters[3],
padding=padding,
maxpool2Dsize=(1, 1),
dropout=dropout,
kernel_initializer="he_normal") #x: 25x25
x = conv_block_2(x,
num_filters[3],
padding=padding,
kernel_initializer="he_normal") #x: 25x25
x = Conv2DTranspose(num_filters[2], (2, 2),
strides=(2, 2),
padding=padding)(x) #x: 50x50
x = conv_block_2(x,
num_filters[2],
padding=padding,
kernel_initializer="he_normal") #x: 50x50
x = Conv2DTranspose(num_filters[1], (2, 2), padding='same')(x) #x: 50x50
x = concatenate([x, x2]) #x: 50x50
x = conv_block_2(x,
num_filters[1],
padding=padding,
kernel_initializer="he_normal") #x: 50x50
x = Conv2DTranspose(num_filters[0], (2, 2),
strides=(2, 2),
padding=padding)(x) #x: 100x100
x = concatenate([x, x1], axis=3) #x: 100x100
x = conv_block_2(x,
num_filters[0],
padding=padding,
kernel_initializer="he_normal") #x: 100x100
infect_seg = Conv2D(1, (1, 1), activation='sigmoid',
name='infect_output')(x) # identifying infections
iseg = Model(inputs=x_input, outputs=infect_seg, name='cts_model')
return iseg
def __init__(self,
image_size,
channels,
conv_layers,
feature_maps,
filter_shapes,
strides,
dense_layers,
dense_neurons,
dense_dropouts,
latent_dim,
activation='relu',
eps_mean=0.0,
eps_std=1.0):
self.history = LossHistory()
# check that arguments are proper length;
if len(filter_shapes) != conv_layers:
raise Exception(
"number of convolutional layers must equal length of filter_shapes list"
)
if len(strides) != conv_layers:
raise Exception(
"number of convolutional layers must equal length of strides list"
)
if len(feature_maps) != conv_layers:
raise Exception(
"number of convolutional layers must equal length of feature_maps list"
)
if len(dense_neurons) != dense_layers:
raise Exception(
"number of dense layers must equal length of dense_neurons list"
)
if len(dense_dropouts) != dense_layers:
raise Exception(
"number of dense layers must equal length of dense_dropouts list"
)
# even shaped filters may cause problems in theano backend;
even_filters = [
f for pair in filter_shapes for f in pair if f % 2 == 0
]
if K.common.image_dim_ordering() == 'th' and len(even_filters) > 0:
warnings.warn(
'Even shaped filters may cause problems in Theano backend')
if K.common.image_dim_ordering(
) == 'channels_first' and len(even_filters) > 0:
warnings.warn(
'Even shaped filters may cause problems in Theano backend')
self.eps_mean = eps_mean
self.eps_std = eps_std
self.image_size = image_size
# define input layer;
if K.common.image_dim_ordering(
) == 'th' or K.common.image_dim_ordering() == 'channels_first':
self.input = Input(shape=(channels, image_size[0], image_size[1]))
else:
self.input = Input(shape=(image_size[0], image_size[1], channels))
# define convolutional encoding layers;
self.encode_conv = []
layer = Convolution2D(feature_maps[0],
filter_shapes[0],
padding='same',
activation=activation,
strides=strides[0])(self.input)
self.encode_conv.append(layer)
for i in range(1, conv_layers):
layer = Convolution2D(feature_maps[i],
filter_shapes[i],
padding='same',
activation=activation,
strides=strides[i])(self.encode_conv[i - 1])
self.encode_conv.append(layer)
# define dense encoding layers;
self.flat = Flatten()(self.encode_conv[-1])
self.encode_dense = []
layer = Dense(dense_neurons[0], activation=activation)(Dropout(
dense_dropouts[0])(self.flat))
self.encode_dense.append(layer)
for i in range(1, dense_layers):
layer = Dense(dense_neurons[i], activation=activation)(Dropout(
dense_dropouts[i])(self.encode_dense[i - 1]))
self.encode_dense.append(layer)
# define embedding layer;
self.z_mean = Dense(latent_dim)(self.encode_dense[-1])
self.z_log_var = Dense(latent_dim)(self.encode_dense[-1])
self.z = Lambda(self._sampling, output_shape=(latent_dim, ))(
[self.z_mean, self.z_log_var])
# save all decoding layers for generation model;
self.all_decoding = []
# define dense decoding layers;
self.decode_dense = []
layer = Dense(dense_neurons[-1], activation=activation)
self.all_decoding.append(layer)
self.decode_dense.append(layer(self.z))
for i in range(1, dense_layers):
layer = Dense(dense_neurons[-i - 1], activation=activation)
self.all_decoding.append(layer)
self.decode_dense.append(layer(self.decode_dense[i - 1]))
# dummy model to get image size after encoding convolutions;
self.decode_conv = []
if K.common.image_dim_ordering(
) == 'th' or K.common.image_dim_ordering() == 'channels_first':
dummy_input = np.ones((1, channels, image_size[0], image_size[1]))
else:
dummy_input = np.ones((1, image_size[0], image_size[1], channels))
dummy = Model(self.input, self.encode_conv[-1])
conv_size = dummy.predict(dummy_input).shape
layer = Dense(conv_size[1] * conv_size[2] * conv_size[3],
activation=activation)
self.all_decoding.append(layer)
self.decode_dense.append(layer(self.decode_dense[-1]))
reshape = Reshape(conv_size[1:])
self.all_decoding.append(reshape)
self.decode_conv.append(reshape(self.decode_dense[-1]))
# define deconvolutional decoding layers;
for i in range(1, conv_layers):
if K.common.image_dim_ordering(
) == 'th' or K.common.image_dim_ordering() == 'channels_first':
dummy_input = np.ones(
(1, channels, image_size[0], image_size[1]))
else:
dummy_input = np.ones(
(1, image_size[0], image_size[1], channels))
dummy = Model(self.input, self.encode_conv[-i - 1])
conv_size = list(dummy.predict(dummy_input).shape)
if K.common.image_dim_ordering(
) == 'th' or K.common.image_dim_ordering() == 'channels_first':
conv_size[1] = feature_maps[-i]
else:
conv_size[3] = feature_maps[-i]
layer = Conv2DTranspose(feature_maps[-i - 1],
filter_shapes[-i],
padding='same',
activation=activation,
strides=strides[-i])
self.all_decoding.append(layer)
self.decode_conv.append(layer(self.decode_conv[i - 1]))
layer = Conv2DTranspose(channels,
filter_shapes[0],
padding='same',
activation='sigmoid',
strides=strides[0])
self.all_decoding.append(layer)
self.output = layer(self.decode_conv[-1])
# build model;
self.model = Model(self.input, self.output)
self.optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
self.model.compile(optimizer=self.optimizer, loss=self._vae_loss)
# print "model summary:"
# self.model.summary()
# model for embeddings;
self.embedder = Model(self.input, self.z_mean)
# model for generation;
self.decoder_input = Input(shape=(latent_dim, ))
self.generation = []
self.generation.append(self.all_decoding[0](self.decoder_input))
for i in range(1, len(self.all_decoding)):
self.generation.append(self.all_decoding[i](self.generation[i -
1]))
self.generator = Model(self.decoder_input, self.generation[-1])
def get_cifar10_model(args):
'''
Return: G, D, GAN models
'''
'''
Build Generator
'''
G_in = Input(shape=(256, ))
x = Dense(256 * 2 * 2, kernel_initializer='glorot_normal')(G_in)
x = Reshape((2, 2, 256))(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2DTranspose(128, (5, 5),
padding='same',
kernel_initializer='glorot_normal',
strides=2)(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2DTranspose(64, (5, 5),
padding='same',
kernel_initializer='glorot_normal',
strides=2)(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2DTranspose(32, (5, 5),
padding='same',
kernel_initializer='glorot_normal',
strides=2)(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2DTranspose(3, (5, 5),
padding='same',
kernel_initializer='glorot_normal',
strides=2)(x)
G_out = Activation('tanh')(x)
G = Model(G_in, G_out)
'''
Build Discriminator
'''
D_in = Input(shape=(32, 32, 3))
x = Conv2D(32, (5, 5),
strides=2,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(args.d_l2),
padding='same')(D_in)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2D(64, (5, 5),
strides=2,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(args.d_l2),
padding='same')(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2D(128, (5, 5),
strides=2,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(args.d_l2),
padding='same')(x)
x = BatchNormalization()(x)
x = LeakyReLU(alpha=0.2)(x)
x = Conv2D(256, (5, 5),
strides=2,
kernel_initializer='glorot_normal',
kernel_regularizer=l2(args.d_l2),
padding='same')(x)
x = LeakyReLU(alpha=0.2)(x)
x = Flatten()(x)
x = Dropout(0.2)(x)
D_out = Dense(1, kernel_initializer='glorot_normal',
activation='sigmoid')(x)
D = Model(D_in, D_out)
dopt = Adam(lr=args.d_lr, beta_1=0.5, beta_2=0.999, decay=1e-5)
D.compile(loss=D_loss, optimizer=dopt)
'''
Building GAN
'''
set_trainability(D, False)
GAN_in = Input(shape=(256, ))
G_out = G(GAN_in)
GAN_out = D(G_out)
GAN = Model(GAN_in, GAN_out)
gopt = Adam(lr=args.g_lr, beta_1=0.5, beta_2=0.999)
GAN.compile(loss=com_conv(G_out, args.beta, 2), optimizer=gopt)
return G, D, GAN
def unet_model(n_classes=5,
im_sz=160,
n_channels=8,
n_filters_start=32,
growth_factor=2):
droprate = 0.25
#Block1
n_filters = n_filters_start
inputs = Input((im_sz, im_sz, n_channels), name='input')
#inputs = BatchNormalization()(inputs)
conv1 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv1_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(inputs)
actv1 = LeakyReLU(name='actv1_1')(conv1)
conv1 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv1_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv1)
actv1 = LeakyReLU(name='actv1_2')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2), name='maxpool1')(actv1)
#pool1 = Dropout(droprate)(pool1)
#Block2
n_filters *= growth_factor
pool1 = BatchNormalization(name='bn1')(pool1)
conv2 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv2_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(pool1)
actv2 = LeakyReLU(name='actv2_1')(conv2)
conv2 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv2_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv2)
actv2 = LeakyReLU(name='actv2_2')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2), name='maxpool2')(actv2)
pool2 = Dropout(droprate, name='dropout2')(pool2)
#Block3
n_filters *= growth_factor
pool2 = BatchNormalization(name='bn2')(pool2)
conv3 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv3_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(pool2)
actv3 = LeakyReLU(name='actv3_1')(conv3)
conv3 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv3_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv3)
actv3 = LeakyReLU(name='actv3_2')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2), name='maxpool3')(actv3)
pool3 = Dropout(droprate, name='dropout3')(pool3)
#Block4
n_filters *= growth_factor
pool3 = BatchNormalization(name='bn3')(pool3)
conv4_0 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv4_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(pool3)
actv4_0 = LeakyReLU(name='actv4_1')(conv4_0)
conv4_0 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv4_0_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv4_0)
actv4_0 = LeakyReLU(name='actv4_2')(conv4_0)
pool4_1 = MaxPooling2D(pool_size=(2, 2), name='maxpool4')(actv4_0)
pool4_1 = Dropout(droprate, name='dropout4')(pool4_1)
#Block5
n_filters *= growth_factor
pool4_1 = BatchNormalization(name='bn4')(pool4_1)
conv4_1 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv5_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(pool4_1)
actv4_1 = LeakyReLU(name='actv5_1')(conv4_1)
conv4_1 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv5_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv4_1)
actv4_1 = LeakyReLU(name='actv5_2')(conv4_1)
pool4_2 = MaxPooling2D(pool_size=(2, 2), name='maxpool5')(actv4_1)
pool4_2 = Dropout(droprate, name='dropout5')(pool4_2)
#Block6
n_filters *= growth_factor
conv5 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv6_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(pool4_2)
actv5 = LeakyReLU(name='actv6_1')(conv5)
conv5 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv6_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv5)
actv5 = LeakyReLU(name='actv6_2')(conv5)
#Block7
n_filters //= growth_factor
up6_1 = concatenate([
Conv2DTranspose(
n_filters,
(2, 2), strides=(2, 2), padding='same', name='up7')(actv5), actv4_1
],
name='concat7')
up6_1 = BatchNormalization(name='bn7')(up6_1)
conv6_1 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv7_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(up6_1)
actv6_1 = LeakyReLU(name='actv7_1')(conv6_1)
conv6_1 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv7_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv6_1)
actv6_1 = LeakyReLU(name='actv7_2')(conv6_1)
conv6_1 = Dropout(droprate, name='dropout7')(actv6_1)
#Block8
n_filters //= growth_factor
up6_2 = concatenate([
Conv2DTranspose(
n_filters, (2, 2), strides=(2, 2), padding='same',
name='up8')(conv6_1), actv4_0
],
name='concat8')
up6_2 = BatchNormalization(name='bn8')(up6_2)
conv6_2 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv8_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(up6_2)
actv6_2 = LeakyReLU(name='actv8_1')(conv6_2)
conv6_2 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv8_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv6_2)
actv6_2 = LeakyReLU(name='actv8_2')(conv6_2)
conv6_2 = Dropout(droprate, name='dropout8')(actv6_2)
#Block9
n_filters //= growth_factor
up7 = concatenate([
Conv2DTranspose(
n_filters,
(2, 2), strides=(2, 2), padding='same', name='up9')(conv6_2), actv3
],
name='concat9')
up7 = BatchNormalization(name='bn9')(up7)
conv7 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv9_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(up7)
actv7 = LeakyReLU(name='actv9_1')(conv7)
conv7 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv9_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv7)
actv7 = LeakyReLU(name='actv9_2')(conv7)
conv7 = Dropout(droprate, name='dropout9')(actv7)
#Block10
n_filters //= growth_factor
up8 = concatenate([
Conv2DTranspose(
n_filters,
(2, 2), strides=(2, 2), padding='same', name='up10')(conv7), actv2
],
name='concat10')
up8 = BatchNormalization(name='bn10')(up8)
conv8 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv10_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(up8)
actv8 = LeakyReLU(name='actv10_1')(conv8)
conv8 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv10_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv8)
actv8 = LeakyReLU(name='actv10_2')(conv8)
conv8 = Dropout(droprate, name='dropout10')(actv8)
#Block11
n_filters //= growth_factor
up9 = concatenate([
Conv2DTranspose(
n_filters,
(2, 2), strides=(2, 2), padding='same', name='up11')(conv8), actv1
],
name='concat11')
conv9 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv11_1',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(up9)
actv9 = LeakyReLU(name='actv11_1')(conv9)
conv9 = Conv2D(n_filters, (3, 3),
padding='same',
name='conv11_2',
kernel_initializer='he_uniform',
bias_initializer='he_uniform')(actv9)
actv9 = LeakyReLU(name='actv11_2')(conv9)
conv10 = Conv2D(n_classes, (1, 1), activation='softmax',
name='output1')(actv9)
model = Model(inputs=inputs, outputs=conv10)
def dice_coef(y_true, y_pred, smooth=1e-7):
y_true_f = K.flatten(y_true)
y_pred_f = K.flatten(y_pred)
intersection = K.sum(y_true_f * y_pred_f)
return (2. * intersection + smooth) / (K.sum(y_true_f) +
K.sum(y_pred_f) + smooth)
"""This simply calculates the dice score for each individual label, and then sums them together, and includes the background."""
def dice_coef_multilabel(y_true, y_pred):
dice = n_classes
for index in range(n_classes):
dice -= dice_coef(y_true[:, :, :, index], y_pred[:, :, :, index])
return dice / n_classes
model.compile(optimizer=Adam(lr=10e-5), loss=dice_coef_multilabel)
return model
def unet(input_shape=(240, 240, 2), bn=True, do=0, ki="he_normal", lr=0.001):
'''
bn: if use batchnorm layer
do: dropout prob
ki: kernel initializer (glorot_uniform, he_normal, ...)
lr: learning rate of Adam
'''
concat_axis = -1 #the last axis (channel axis)
inputs = Input(input_shape) # channels is 2: <t1, flair>
conv1 = Conv2D(64, (5, 5),
padding="same",
activation="relu",
kernel_initializer=ki)(inputs)
conv1 = BatchNormalization()(conv1) if bn else conv1
conv1 = Dropout(do)(conv1) if do else conv1
conv1 = Conv2D(64, (5, 5),
padding="same",
activation="relu",
kernel_initializer=ki)(conv1)
conv1 = BatchNormalization()(conv1) if bn else conv1
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(96, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(pool1)
conv2 = BatchNormalization()(conv2) if bn else conv2
conv2 = Dropout(do)(conv2) if do else conv2
conv2 = Conv2D(96, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(conv2)
conv2 = BatchNormalization()(conv2) if bn else conv2
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(128, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(pool2)
conv3 = BatchNormalization()(conv3) if bn else conv3
conv3 = Dropout(do)(conv3) if do else conv3
conv3 = Conv2D(128, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(conv3)
conv3 = BatchNormalization()(conv3) if bn else conv3
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(256, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(pool3)
conv4 = BatchNormalization()(conv4) if bn else conv4
conv4 = Dropout(do)(conv4) if do else conv4
conv4 = Conv2D(256, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(conv4)
conv4 = BatchNormalization()(conv4) if bn else conv4
#######
conv4 = Conv2D(512, (3, 3),
dilation_rate=2,
padding="same",
activation="relu",
kernel_initializer=ki)(conv4)
cat6 = conv4
# pool4 = MaxPooling2D(pool_size=(2,2))(conv4)
#
# conv5 = Conv2D(512, (3,3), padding="same", activation="relu", kernel_initializer=ki)(pool4)
# conv5 = BatchNormalization()(conv5) if bn else conv5
# conv5 = Dropout(do)(conv5) if do else conv5
# conv5 = Conv2D(512, (3,3), padding="same", activation="relu", kernel_initializer=ki)(conv5)
# conv5 = BatchNormalization()(conv5) if bn else conv5
# upconv5 = Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same', kernel_initializer=ki)(conv5)
#
# ch, cw = get_crop_shape(conv4, upconv5)
# crop_conv4 = Cropping2D(cropping=(ch,cw))(conv4)
# cat6 = concatenate([upconv5, crop_conv4], axis=concat_axis)
conv6 = Conv2D(256, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(cat6)
conv6 = BatchNormalization()(conv6) if bn else conv6
conv6 = Dropout(do)(conv6) if do else conv6
conv6 = Conv2D(256, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(conv6)
conv6 = BatchNormalization()(conv6) if bn else conv6
upconv6 = Conv2DTranspose(128, (2, 2),
strides=(2, 2),
padding='same',
kernel_initializer=ki)(conv6)
ch, cw = get_crop_shape(conv3, upconv6)
crop_conv3 = Cropping2D(cropping=(ch, cw))(conv3)
up7 = concatenate([upconv6, crop_conv3], axis=concat_axis)
conv7 = Conv2D(128, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(up7)
conv7 = BatchNormalization()(conv7) if bn else conv7
conv7 = Dropout(do)(conv7) if do else conv7
conv7 = Conv2D(128, (3, 3), padding="same", activation="relu")(conv7)
conv7 = BatchNormalization()(conv7) if bn else conv7
upconv7 = Conv2DTranspose(96, (2, 2),
strides=(2, 2),
padding='same',
kernel_initializer=ki)(conv7)
ch, cw = get_crop_shape(conv2, upconv7)
crop_conv2 = Cropping2D(cropping=(ch, cw))(conv2)
up8 = concatenate([upconv7, crop_conv2], axis=concat_axis)
conv8 = Conv2D(96, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(up8)
conv8 = BatchNormalization()(conv8) if bn else conv8
conv8 = Dropout(do)(conv8) if do else conv8
conv8 = Conv2D(96, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(conv8)
conv8 = BatchNormalization()(conv8) if bn else conv8
upconv8 = Conv2DTranspose(64, (2, 2),
strides=(2, 2),
padding='same',
kernel_initializer=ki)(conv8)
ch, cw = get_crop_shape(conv1, upconv8)
crop_conv1 = Cropping2D(cropping=(ch, cw))(conv1)
up9 = concatenate([upconv8, crop_conv1], axis=concat_axis)
conv9 = Conv2D(64, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(up9)
conv9 = BatchNormalization()(conv9) if bn else conv9
conv9 = Conv2D(64, (3, 3),
padding="same",
activation="relu",
kernel_initializer=ki)(conv9)
conv9 = BatchNormalization()(conv9) if bn else conv9
ch, cw = get_pad_shape(conv9, conv1)
pad_conv9 = ZeroPadding2D(padding=(ch, cw))(conv9)
conv9 = Conv2D(1, (1, 1),
padding="same",
activation="sigmoid",
kernel_initializer=ki)(pad_conv9) #change to sigmoid
model = Model(inputs=inputs, outputs=conv9)
# optimizer = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) #default
optimizer = Adam(lr=lr, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
# optimizer = Adagrad(lr=0.001, epsilon=1e-08, decay=0.0)
# model.compile(optimizer=optimizer, loss="binary_crossentropy", metrics=['accuracy'])
# optimizer = SGD(lr=0.1, momentum=0.8, decay=lr/30, nesterov=False)
# model.compile(optimizer=optimizer, loss=dice_coef_loss, metrics=[dice_coef, 'accuracy'])
model.compile(optimizer=optimizer,
loss=dice_coef_loss,
metrics=[dice_coef, precision_xue, recall_xue])
return model
def architecture(self):
config = get_config()
config = config["train"]["optimizers"]
channels, height, weight = 3, 500, 500
# Input
input_shape = (height, weight, 3)
img_input = Input(shape=self.input_shape)
#img_input = Cropping2D((3,3))(img_input)
# Add plenty of zero padding
x = ZeroPadding2D(padding=(218, 218))(img_input)
# VGG-16 convolution block 1
x = Conv2D(64, (3, 3), activation='relu', padding='valid', name='conv1_1')(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='conv1_2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(x)
# VGG-16 convolution block 2
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_1')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool2', padding='same')(x)
# VGG-16 convolution block output3
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_1')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_2')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool3', padding='same')(x)
pool3 = x
# VGG-16 convolution block 4
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool4', padding='same')(x)
pool4 = x
# VGG-16 convolution block 5
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool5', padding='same')(x)
# Fully-connected layers converted to convolution layers
x = Conv2D(128, (7, 7), activation='relu', padding='valid', name='fc6')(x)
x = Dropout(0.5)(x)
x = Conv2D(128, (1, 1), activation='relu', padding='valid', name='fc7')(x)
x = Dropout(0.5)(x)
x = Conv2D(21, (1, 1), padding='valid', name='score-fr')(x)
# Deconvolution
score2 = Conv2DTranspose(1, (4, 4), strides=2, name='score2')(x)
# Skip connections from pool4
score_pool4 = Conv2D(1, (1, 1), name='score-pool4')(pool4)
score_pool4c = Cropping2D((5, 5))(score_pool4)
score_fused = Add()([score2, score_pool4c])
score4 = Conv2DTranspose(1, (4, 4), strides=2, name='score4', use_bias=False)(score_fused)
# Skip connections from pool3
score_pool3 = Conv2D(1, (1, 1), name='score-pool3')(pool3)
score_pool3c = Cropping2D((9, 9))(score_pool3)
score_pool3c = ZeroPadding2D(padding=((1,0), (1,0)))(score_pool3c)
# Fuse things together
score_final = Add()([score4, score_pool3c])
# Final up-sampling and cropping
upsample = Conv2DTranspose(1, (4, 4), strides=4, name='upsample', use_bias=False)(score_final)
upscore = Cropping2D(((56, 56), (56, 56)))(upsample)
upscore = Cropping2D(((4, 4), (4, 4)))(upscore)
output = CrfRnnLayer(image_dims=(64, 64),
num_classes=1,
theta_alpha= config["crf_theta_alpha"], #3
theta_beta= config["crf_theta_beta"], #3
theta_gamma= config["crf_theta_gamma"], #3
num_iterations= config["crf_num_iterations"],
name='crfrnn')([upscore, img_input])
classi = Add()([upscore, output])
k = Flatten()(classi)
k = Dense(128, activation='relu')(k)
k = Dropout(.5)(k)
k = Dense(256, activation='relu')(k)
predictions = Dense(1, activation='sigmoid')(k)
# Build the model
model = Model(img_input, predictions, name='CRFVGG')
return model
def fn(tensor):
x = Conv2DTranspose(nb_filters, 3, padding="same",
strides=(2, 2))(tensor)
return x
z = Lambda(sampling, output_shape=(latent_dim,), name='z')([z_mean, z_log_var])
# instantiate encoder model
encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder')
encoder.summary()
#plot_model(encoder, to_file='vae_cnn_encoder.png', show_shapes=True)
# build decoder model
latent_inputs = Input(shape=(latent_dim,), name='z_sampling')
x = Dense(shape[1] * shape[2] * shape[3], activation='relu')(latent_inputs)
x = Reshape((shape[1], shape[2], shape[3]))(x)
for i in range(3):
x = Conv2DTranspose(filters=filters,
kernel_size=kernel_size,
activation='relu',
strides=2,
padding='same')(x)
filters //= 2
outputs = Conv2DTranspose(filters=1,
kernel_size=kernel_size,
activation='sigmoid',
padding='same',
name='decoder_output')(x)
# instantiate decoder model
decoder = Model(latent_inputs, outputs, name='decoder')
decoder.summary()
#plot_model(decoder, to_file='vae_cnn_decoder.png', show_shapes=True)
def get_unet_preenc(
self,
k=10,
lr=1e-4,
f_out=2,
):
"""
:param k:
:param lr:
:param f_out:
:return:
"""
from keras.layers import Conv2D, UpSampling2D, Concatenate, Cropping2D, Conv2DTranspose, BatchNormalization
from methods.examples import compile_segm
model_encoder = self.get_encoder(k)
b_double = False
padding = 'valid'
encoder_outputs = model_encoder.output
l = encoder_outputs
if self.depth == 2:
list_w_crop = [12, 4]
elif self.depth == 1:
list_w_crop = [4]
for i_d in range(self.depth)[::-1]:
f = 2**i_d * k if b_double else k
l = Conv2D(f, (3, 3),
activation='elu',
padding=padding,
name=f'dec{i_d+1}')(l)
if self.batch_norm:
l = BatchNormalization(name=f'batchnorm_dec{i_d+1}')(l)
if 0:
l = UpSampling2D(2)(l)
else:
l = Conv2DTranspose(f, (2, 2), strides=(2, 2))(l)
if self.batch_norm:
l = BatchNormalization(name=f'batchnorm_up{i_d}')(l)
# Combine
l_left_crop = Cropping2D(list_w_crop[i_d], name=f'crop_enc{i_d}')(
model_encoder.get_layer(f'enc{i_d}').output)
l = Concatenate(name=f'conc_dec{i_d}')([l, l_left_crop])
l = Conv2D(k, (3, 3),
activation='elu',
padding=padding,
name=f'dec{0}')(l)
if self.batch_norm:
l = BatchNormalization(name=f'batchnorm_dec{0}')(l)
decoder_outputs = Conv2D(f_out, (1, 1),
activation='softmax',
padding=padding)(l)
model_pretrained_unet = Model(model_encoder.input, decoder_outputs)
compile_segm(model_pretrained_unet, lr=lr)
model_pretrained_unet.summary()
return model_pretrained_unet
def build(self):
"""
Build the model for training
"""
print('. . . . .Building ENet. . . . .')
img_input = Input(shape=(self.im_height, self.im_width, 3),
name='image_input')
x = self.initial_block(img_input)
x = self.bottleneck_encoder(x,
64,
downsampling=True,
normal=True,
name='1.0',
drate=0.01)
for _ in range(1, 5):
x = self.bottleneck_encoder(x,
64,
normal=True,
name=f'1.{_}',
drate=0.01)
# Encoder Block
x = self.bottleneck_encoder(x,
128,
downsampling=True,
normal=True,
name=f'2.0')
x = self.bottleneck_encoder(x, 128, normal=True, name=f'2.1')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'2.2')
x = self.bottleneck_encoder(x, 128, asymmetric=True, name=f'2.3')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'2.4')
x = self.bottleneck_encoder(x, 128, normal=True, name=f'2.5')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'2.6')
x = self.bottleneck_encoder(x, 128, asymmetric=True, name=f'2.7')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'2.8')
x = self.bottleneck_encoder(x, 128, normal=True, name=f'3.0')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'3.1')
x = self.bottleneck_encoder(x, 128, asymmetric=True, name=f'3.2')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'3.3')
x = self.bottleneck_encoder(x, 128, normal=True, name=f'3.4')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'3.5')
x = self.bottleneck_encoder(x, 128, asymmetric=True, name=f'3.6')
x = self.bottleneck_encoder(x, 128, dilated=True, name=f'3.7')
# Decoder Block
x = self.bottleneck_decoder(x, 64, upsampling=True, name='4.0')
x = self.bottleneck_decoder(x, 64, normal=True, name='4.1')
x = self.bottleneck_decoder(x, 64, normal=True, name='4.2')
x = self.bottleneck_decoder(x, 16, upsampling=True, name='5.0')
x = self.bottleneck_decoder(x, 16, normal=True, name='5.1')
img_output = Conv2DTranspose(self.nclasses,
kernel_size=(2, 2),
strides=(2, 2),
kernel_initializer='he_normal',
padding='same',
name='image_output')(x)
img_output = Activation('softmax')(img_output)
model = Model(inputs=img_input, outputs=img_output, name='ENET')
print('. . . . .Build Compeleted. . . . .')
return model
def load_generator_network(batch_size,
sequence_class,
n_classes=1,
seq_length=205,
supply_inputs=False):
sequence_class_onehots = np.eye(n_classes)
#Generator network parameters
latent_size = 100
#Generator inputs
latent_input_1, latent_input_2, latent_input_1_out, latent_input_2_out = None, None, None, None
if not supply_inputs:
latent_input_1 = Input(tensor=K.ones((batch_size, latent_size)),
name='noise_input_1')
latent_input_2 = Input(tensor=K.ones((batch_size, latent_size)),
name='noise_input_2')
latent_input_1_out = Lambda(lambda inp: inp * K.random_uniform(
(batch_size, latent_size), minval=-1.0, maxval=1.0),
name='lambda_rand_input_1')(latent_input_1)
latent_input_2_out = Lambda(lambda inp: inp * K.random_uniform(
(batch_size, latent_size), minval=-1.0, maxval=1.0),
name='lambda_rand_input_2')(latent_input_2)
else:
latent_input_1 = Input(batch_shape=K.ones(batch_size, latent_size),
name='noise_input_1')
latent_input_2 = Input(batch_shape=K.ones(batch_size, latent_size),
name='noise_input_2')
latent_input_1_out = Lambda(lambda inp: inp,
name='lambda_rand_input_1')(latent_input_1)
latent_input_2_out = Lambda(lambda inp: inp,
name='lambda_rand_input_2')(latent_input_2)
class_embedding = Lambda(lambda x: K.gather(
K.constant(sequence_class_onehots), K.cast(x[:, 0], dtype='int32')))(
sequence_class)
seed_input_1 = Concatenate(axis=-1)([latent_input_1_out, class_embedding])
seed_input_2 = Concatenate(axis=-1)([latent_input_2_out, class_embedding])
#Policy network definition
policy_dense_1 = Dense(21 * 384,
activation='relu',
kernel_initializer='glorot_uniform',
name='policy_dense_1')
policy_dense_1_reshape = Reshape((21, 1, 384))
policy_deconv_0 = Conv2DTranspose(256, (7, 1),
strides=(2, 1),
padding='valid',
activation='linear',
kernel_initializer='glorot_normal',
name='policy_deconv_0')
policy_deconv_1 = Conv2DTranspose(192, (8, 1),
strides=(2, 1),
padding='valid',
activation='linear',
kernel_initializer='glorot_normal',
name='policy_deconv_1')
policy_deconv_2 = Conv2DTranspose(128, (7, 1),
strides=(2, 1),
padding='valid',
activation='linear',
kernel_initializer='glorot_normal',
name='policy_deconv_2')
policy_conv_3 = Conv2D(128, (8, 1),
strides=(1, 1),
padding='same',
activation='linear',
kernel_initializer='glorot_normal',
name='policy_conv_3')
policy_conv_4 = Conv2D(64, (8, 1),
strides=(1, 1),
padding='same',
activation='linear',
kernel_initializer='glorot_normal',
name='policy_conv_4')
policy_conv_5 = Conv2D(4, (8, 1),
strides=(1, 1),
padding='same',
activation='linear',
kernel_initializer='glorot_normal',
name='policy_conv_5')
#policy_deconv_3 = Conv2DTranspose(4, (7, 1), strides=(1, 1), padding='valid', activation='linear', kernel_initializer='glorot_normal', name='policy_deconv_3')
batch_norm_0 = BatchNormalization(name='policy_batch_norm_0')
relu_0 = Lambda(lambda x: K.relu(x))
batch_norm_1 = BatchNormalization(name='policy_batch_norm_1')
relu_1 = Lambda(lambda x: K.relu(x))
batch_norm_2 = BatchNormalization(name='policy_batch_norm_2')
relu_2 = Lambda(lambda x: K.relu(x))
batch_norm_3 = BatchNormalization(name='policy_batch_norm_3')
relu_3 = Lambda(lambda x: K.relu(x))
batch_norm_4 = BatchNormalization(name='policy_batch_norm_4')
relu_4 = Lambda(lambda x: K.relu(x))
policy_out_1 = Reshape((seq_length, 4, 1))(policy_conv_5(
relu_4(
batch_norm_4(
policy_conv_4(
relu_3(
batch_norm_3(
policy_conv_3(
relu_2(
batch_norm_2(
policy_deconv_2(
relu_1(
batch_norm_1(
policy_deconv_1(
relu_0(
batch_norm_0(
policy_deconv_0(
policy_dense_1_reshape(
policy_dense_1(
seed_input_1
)))))))
))))))))))))
policy_out_2 = Reshape((seq_length, 4, 1))(policy_conv_5(
relu_4(
batch_norm_4(
policy_conv_4(
relu_3(
batch_norm_3(
policy_conv_3(
relu_2(
batch_norm_2(
policy_deconv_2(
relu_1(
batch_norm_1(
policy_deconv_1(
relu_0(
batch_norm_0(
policy_deconv_0(
policy_dense_1_reshape(
policy_dense_1(
seed_input_2
)))))))
))))))))))))
return [latent_input_1, latent_input_2], [policy_out_1, policy_out_2], []
def _build(self):
vae_x = Input(shape=self.input_dim)
vae_c1 = Conv2D(filters=32,
kernel_size=4,
strides=2,
activation="relu")(vae_x)
vae_c2 = Conv2D(filters=64,
kernel_size=4,
strides=2,
activation="relu")(vae_c1)
vae_c3 = Conv2D(filters=64,
kernel_size=4,
strides=2,
activation="relu")(vae_c2)
vae_c4 = Conv2D(filters=128,
kernel_size=4,
strides=2,
activation="relu")(vae_c3)
vae_z_in = Flatten()(vae_c4)
vae_z_mean = Dense(self.z_dim)(vae_z_in)
vae_z_log_var = Dense(self.z_dim)(vae_z_in)
vae_z = Lambda(sampling)([vae_z_mean, vae_z_log_var])
vae_z_input = Input(shape=(self.z_dim, ))
vae_dense = Dense(1024)
vae_dense_model = vae_dense(vae_z)
vae_z_out = Reshape((1, 1, VAE_DENSE_SIZE))
vae_z_out_model = vae_z_out(vae_dense_model)
vae_d1 = Conv2DTranspose(filters=64,
kernel_size=5,
strides=2,
activation="relu")
vae_d1_model = vae_d1(vae_z_out_model)
vae_d2 = Conv2DTranspose(filters=64,
kernel_size=5,
strides=2,
activation="relu")
vae_d2_model = vae_d2(vae_d1_model)
vae_d3 = Conv2DTranspose(filters=32,
kernel_size=6,
strides=2,
activation="relu")
vae_d3_model = vae_d3(vae_d2_model)
vae_d4 = Conv2DTranspose(filters=3,
kernel_size=6,
strides=2,
activation="sigmoid")
vae_d4_model = vae_d4(vae_d3_model)
# Decoder
vae_dense_decoder = vae_dense(vae_z_input)
vae_z_out_decoder = vae_z_out(vae_dense_decoder)
vae_d1_decoder = vae_d1(vae_z_out_decoder)
vae_d2_decoder = vae_d2(vae_d1_decoder)
vae_d3_decoder = vae_d3(vae_d2_decoder)
vae_d4_decoder = vae_d4(vae_d3_decoder)
# Models
vae = Model(vae_x, vae_d4_model)
vae_encoder = Model(vae_x, vae_z)
vae_decoder = Model(vae_z_input, vae_d4_decoder)
def vae_r_loss(y_true, y_pred):
return K.sum(K.square(y_true - y_pred), axis=[1, 2, 3])
def vae_kl_loss(y_true, y_pred):
return -0.5 * K.sum(1 + vae_z_log_var - K.square(vae_z_mean) -
K.exp(vae_z_log_var),
axis=-1)
def vae_loss(y_true, y_pred):
return vae_r_loss(y_true, y_pred) + vae_kl_loss(y_true, y_pred)
vae.compile(optimizer='rmsprop',
loss=vae_loss,
metrics=[vae_r_loss, vae_kl_loss])
return vae, vae_encoder, vae_decoder
def fit(self, training_set, training_data_name=None):
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
# config = tf.ConfigProto()
# #config.gpu_options.allow_growth = True
# config.gpu_options.per_process_gpu_memory_fraction = 0.8
# sess = tf.Session(config=config)
# set_session(sess)
temp_training_set = []
if training_data_name is not None:
self.training_data_name = training_data_name
if any(isinstance(el, list) for el in
training_set): # if training set is a sequence of frames
for sequence in training_set:
transformed_frames = self.input_frames_transform(
np.array(sequence))
temp_training_set += self.get_training_set(transformed_frames)
else:
transformed_frames = self.input_frames_transform(
np.array(training_set))
temp_training_set = self.get_training_set(transformed_frames)
final_training_set = np.array(temp_training_set)
seq = Sequential()
seq.add(
TimeDistributed(Conv2D(128, (11, 11), strides=4, padding="same"),
batch_input_shape=(None, 10, 256, 256, 1)))
seq.add(LayerNormalization())
seq.add(TimeDistributed(Conv2D(64, (5, 5), strides=2, padding="same")))
seq.add(LayerNormalization())
# # # # #
seq.add(ConvLSTM2D(64, (3, 3), padding="same", return_sequences=True))
seq.add(LayerNormalization())
seq.add(ConvLSTM2D(32, (3, 3), padding="same", return_sequences=True))
seq.add(LayerNormalization())
seq.add(ConvLSTM2D(64, (3, 3), padding="same", return_sequences=True))
seq.add(LayerNormalization())
# # # # #
seq.add(
TimeDistributed(
Conv2DTranspose(64, (5, 5), strides=2, padding="same")))
seq.add(LayerNormalization())
seq.add(
TimeDistributed(
Conv2DTranspose(128, (11, 11), strides=4, padding="same")))
seq.add(LayerNormalization())
seq.add(
TimeDistributed(
Conv2D(1, (11, 11), activation="sigmoid", padding="same")))
print(seq.summary())
seq.compile(loss='mse',
optimizer=keras.optimizers.Adam(lr=1e-4,
decay=1e-5,
epsilon=1e-6))
seq.fit(final_training_set,
final_training_set,
batch_size=self.batch_size,
epochs=self.epochs,
shuffle=False)
self.model = seq
self.save_model()
def get_unet_extended():
metrics = dice_coef
include_label_wise_dice_coefficients = True;
inputs = Input((patch_size, patch_size, 1))
conv1 = Conv2D(BASE, (3, 3), activation='relu', padding='same')(inputs)
conv1 = Conv2D(BASE, (3, 3), activation='relu', padding='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(BASE*2, (3, 3), activation='relu', padding='same')(pool1)
conv2 = Conv2D(BASE*2, (3, 3), activation='relu', padding='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(BASE*4, (3, 3), activation='relu', padding='same')(pool2)
conv3 = Conv2D(BASE*4, (3, 3), activation='relu', padding='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(BASE*8, (3, 3), activation='relu', padding='same')(pool3)
conv4 = Conv2D(BASE*8, (3, 3), activation='relu', padding='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Conv2D(BASE*16, (3, 3), activation='relu', padding='same')(pool4)
conv5 = Conv2D(BASE*16, (3, 3), activation='relu', padding='same')(conv5)
pool5 = MaxPooling2D(pool_size=(2, 2))(conv5)
conv5_extend = Conv2D(BASE*32, (3, 3), activation='relu', padding='same')(pool5)
conv5_extend = Conv2D(BASE*32, (3, 3), activation='relu', padding='same')(conv5_extend)
up6_extend = concatenate([Conv2DTranspose(BASE*16, (2, 2), strides=(2, 2), padding='same')(conv5_extend), conv5], axis=3)
conv6_extend = Conv2D(BASE*16, (3, 3), activation='relu', padding='same')(up6_extend)
conv6_extend = Conv2D(BASE*16, (3, 3), activation='relu', padding='same')(conv6_extend)
up6 = concatenate([Conv2DTranspose(BASE*8, (2, 2), strides=(2, 2), padding='same')(conv6_extend), conv4], axis=3)
conv6 = Conv2D(BASE*8, (3, 3), activation='relu', padding='same')(up6)
conv6 = Conv2D(BASE*8, (3, 3), activation='relu', padding='same')(conv6)
up7 = concatenate([Conv2DTranspose(BASE*4, (2, 2),strides=(2, 2), padding='same')(conv6), conv3], axis=3)
conv7 = Conv2D(BASE*4, (3, 3), activation='relu', padding='same')(up7)
conv7 = Conv2D(BASE*4, (3, 3), activation='relu', padding='same')(conv7)
up8 = concatenate([Conv2DTranspose(BASE*2, (2, 2), strides=(2, 2), padding='same')(conv7), conv2], axis=3)
conv8 = Conv2D(BASE*2, (3, 3), activation='relu', padding='same')(up8)
conv8 = Conv2D(BASE*2, (3, 3), activation='relu', padding='same')(conv8)
up9 = concatenate([Conv2DTranspose(BASE, (2, 2), strides=(2, 2), padding='same')(conv8), conv1], axis=3)
conv9 = Conv2D(BASE, (3, 3), activation='relu', padding='same')(up9)
conv9 = Conv2D(BASE, (3, 3), activation='relu', padding='same')(conv9)
conv10 = Conv2D(num_classes, (1, 1), activation='sigmoid')(conv9)
model = Model(inputs=[inputs], outputs=[conv10])
if not isinstance(metrics, list):
metrics = [metrics]
if include_label_wise_dice_coefficients and num_classes > 1:
label_wise_dice_metrics = [get_label_dice_coefficient_function(index) for index in range(num_classes)]
if metrics:
metrics = metrics + label_wise_dice_metrics
else:
metrics = label_wise_dice_metrics
model.compile(optimizer=Adam(lr=1e-4), loss=dice_coef_loss, metrics=metrics)
return model
def mkPretrainedVGG16():
model = keras.applications.VGG16(input_shape=(targetShape[0],
targetShape[1], 3),
include_top=False,
weights='imagenet')
#for l in model.layers:
# l.trainable = False
input = model.inputs[0]
vggOutput = model.outputs[0]
x = vggOutput
block4Pool = model.get_layer('block4_pool').output
block4Shortcut = Conv2D(2,
kernel_size=(1, 1),
kernel_initializer='he_normal')(block4Pool)
block3Pool = model.get_layer('block3_pool').output
block3Shortcut = Conv2D(2,
kernel_size=(1, 1),
kernel_initializer='he_normal')(block3Pool)
x = Conv2D(2,
kernel_size=(1, 1),
strides=(1, 1),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(2,
kernel_size=(4, 4),
strides=(2, 2),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Add()([x, block4Shortcut])
x = Conv2DTranspose(2,
kernel_size=(4, 4),
strides=(2, 2),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Add()([x, block3Shortcut])
x = Conv2DTranspose(2,
kernel_size=(16, 16),
strides=(8, 8),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
fcnOutput = x
x = vggOutput
x = Flatten()(x)
x = Dense(4 * 4 * 512)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Reshape((4, 4, 512))(x)
x = Conv2DTranspose(512,
kernel_size=(4, 4),
strides=(1, 1),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D()(x) #8 8
x = Conv2DTranspose(512,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(512,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(512,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D()(x) #16 16
x = Conv2DTranspose(256,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(256,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(256,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D()(x) #32 32
x = Conv2DTranspose(128,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(128,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(128,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D()(x) #64 64
x = Conv2DTranspose(64,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(64,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = UpSampling2D()(x) #128 128
x = Conv2DTranspose(64,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2DTranspose(64,
kernel_size=(3, 3),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(2,
kernel_size=(1, 1),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
deconvOutput = x
x = Concatenate()([deconvOutput, fcnOutput])
#x = Dropout(0.2)(x)
x = Conv2D(1,
kernel_size=(1, 1),
strides=(1, 1),
kernel_initializer='he_normal',
padding='same')(x)
x = BatchNormalization()(x)
x = Activation('sigmoid')(x)
model = Model(inputs=[input], outputs=[x])
print model.summary()
return model
strides=(1, 1),
activation='relu',
name='Conv7'))
model.add(Dropout(0.2))
# Pooling 3
model.add(MaxPooling2D(pool_size=pool_size))
# Upsample 1
model.add(UpSampling2D(size=pool_size))
# Deconv 1
model.add(
Conv2DTranspose(64, (3, 3),
padding='valid',
strides=(1, 1),
activation='relu',
name='Deconv1'))
model.add(Dropout(0.2))
# Deconv 2
model.add(
Conv2DTranspose(64, (3, 3),
padding='valid',
strides=(1, 1),
activation='relu',
name='Deconv2'))
model.add(Dropout(0.2))
# Upsample 2
model.add(UpSampling2D(size=pool_size))
c3 = Conv2D(40, (2, 2), activation=act_fn, kernel_initializer='he_normal', padding='same') (p2) c3 = Dropout(0.2) (c3) c3 = Conv2D(40, (2, 2), activation=act_fn, kernel_initializer='he_normal', padding='same') (c3) p3 = MaxPooling2D((2, 2)) (c3) c4 = Conv2D(40, (2, 2), activation=act_fn, kernel_initializer='he_normal', padding='same') (p3) c4 = Dropout(0.2) (c4) c4 = Conv2D(40, (2, 2), activation=act_fn, kernel_initializer='he_normal', padding='same') (c4) p4 = MaxPooling2D(pool_size=(1, 1)) (c4) c5 = Conv2D(80, (2, 2), activation=act_fn, kernel_initializer='he_normal', padding='same') (p4) c5 = Dropout(0.2) (c5) c5 = Conv2D(80, (2, 2), activation=act_fn, kernel_initializer='he_normal', padding='same') (c5) u6 = Conv2DTranspose(40, (2, 2), strides=(1, 1), padding='same') (c5) u6 = concatenate([u6, c4]) c6 = Conv2D(40, (3, 3), activation=act_fn, kernel_initializer='he_normal', padding='same') (u6) c6 = Dropout(0.2) (c6) c6 = Conv2D(40, (3, 3), activation=act_fn, kernel_initializer='he_normal', padding='same') (c6) u7 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c6) u7 = concatenate([u7, c3]) c7 = Conv2D(64, (3, 3), activation=act_fn, kernel_initializer='he_normal', padding='same') (u7) c7 = Dropout(0.2) (c7) c7 = Conv2D(64, (3, 3), activation=act_fn, kernel_initializer='he_normal', padding='same') (c7) u8 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c7) u8 = concatenate([u8, c2]) c8 = Conv2D(32, (3, 3), activation=act_fn, kernel_initializer='he_normal', padding='same') (u8) c8 = Dropout(0.1) (c8)
