def build_generator():
# specify hyperparameters
z_size = 200
gen_filters = [512, 256, 128, 64, 1]
gen_kernel_sizes = [4, 4, 4, 4, 4]
gen_strides = [1, 2, 2, 2, 2]
gen_input_shape = (1, 1, 1, z_size)
gen_activations = ['relu', 'relu', 'relu', 'relu', 'sigmoid']
gen_convolutional_blocks = 5
# create an input layer to allow the network to take input
input_layer = Input(shape=gen_input_shape)
# add the first transpose convolution (3D deconvolution) block
a = Deconv3D(filters=gen_filters[0],
kernel_size=gen_kernel_sizes[0],
strides=gen_strides[0])(input_layer)
a = BatchNormalization()(a, training=True)
a = Activation(activation='relu')(a)
# add four more 3D transpose convolutions blocks
for i in range(gen_convolutional_blocks - 1):
a = Deconv3D(filters=gen_filters[i + 1],
kernel_size=gen_kernel_sizes[i + 1],
strides=gen_strides[i + 1],
padding='same')(a)
a = BatchNormalization()(a, training=True)
a = Activation(activation=gen_activations[i + 1])(a)
# create a Keras model
gen_model = Model(inputs=[input_layer], outputs=[a])
return gen_model
def build_generator():
"""
Create a Generator Model with hyperparameters values defined as follows
"""
z_size = 200
gen_filters = [512, 256, 128, 64, 1]
gen_kernel_sizes = [4, 4, 4, 4, 4]
gen_strides = [1, 2, 2, 2, 2]
gen_input_shape = (1, 1, 1, z_size)
gen_activations = ['relu', 'relu', 'relu', 'relu', 'sigmoid']
gen_convolutional_blocks = 5
input_layer = Input(shape=gen_input_shape)
# First 3D transpose convolution(or 3D deconvolution) block
a = Deconv3D(filters=gen_filters[0],
kernel_size=gen_kernel_sizes[0],
strides=gen_strides[0])(input_layer)
a = BatchNormalization()(a, training=True)
a = Activation(activation='relu')(a)
# Next 4 3D transpose convolution(or 3D deconvolution) blocks
for i in range(gen_convolutional_blocks - 1):
a = Deconv3D(filters=gen_filters[i + 1],
kernel_size=gen_kernel_sizes[i + 1],
strides=gen_strides[i + 1],
padding='same')(a)
a = BatchNormalization()(a, training=True)
a = Activation(activation=gen_activations[i + 1])(a)
gen_model = Model(inputs=[input_layer], outputs=[a])
return gen_model
def build_generator():
'''
Build the Generator Model of the 3D-GAN.
Returns: Generator Network
'''
z_size = 200
gen_filters = [512, 256, 128, 64, 1]
gen_kernel_sizes = [4, 4, 4, 4, 4]
gen_strides = [1, 2, 2, 2, 2]
gen_input_shape = (1, 1, 1, z_size)
gen_activations = ['relu', 'relu', 'relu', 'relu', 'sigmoid']
gen_convolutional_blocks = 5
input_layer = Input(shape=gen_input_shape)
# First 3D transpose convolution(or 3D deconvolution) block
a = Deconv3D(filters=gen_filters[0],
kernel_size=gen_kernel_sizes[0],
strides=gen_strides[0])(input_layer)
a = BatchNormalization()(a, training=True)
a = Activation(activation='relu')(a)
# Next 4 3D transpose convolution(or 3D deconvolution) blocks
for i in range(gen_convolutional_blocks - 1):
a = Deconv3D(filters=gen_filters[i + 1],
kernel_size=gen_kernel_sizes[i + 1],
strides=gen_strides[i + 1],
padding='same')(a)
a = BatchNormalization()(a, training=True)
a = Activation(activation=gen_activations[i + 1])(a)
gen_model = Model(inputs=[input_layer], outputs=[a])
return gen_model
def build_generator(phase_train=True,
params={
'latent_dim': 200,
'strides': (2, 2, 2)
}):
l_dim = params['latent_dim']
strides = params['strides']
inputs = Input(shape=(l_dim, ))
reshape = Reshape((22, 4, 1, 1), input_shape=(l_dim, ))(inputs)
group1 = Deconv3D(512, (2, 2, 2),
strides=(2, 2, 2),
kernel_initializer='glorot_normal',
bias_initializer='zeros')(reshape)
group1 = BatchNormalization()(group1, training=phase_train)
group1 = Activation(activation='relu')(group1)
group2 = Deconv3D(64, (2, 2, 2),
strides=(2, 2, 2),
kernel_initializer='glorot_normal',
bias_initializer='zeros')(group1)
group2 = BatchNormalization()(group2, training=phase_train)
group2 = Activation(activation='relu')(group2)
group3 = Deconv3D(1, (2, 2, 2),
strides=(2, 2, 2),
kernel_initializer='glorot_normal',
bias_initializer='zeros')(group2)
group3 = BatchNormalization()(group3, training=phase_train)
group3 = Activation(activation='relu')(group3)
generator = Model(inputs, group3)
generator.summary()
return generator
def build_model_2():
model = Sequential()
model.add(
Conv3D(32,
kernel_size=(2, 2, 2),
padding='same',
activation='relu',
input_shape=input_shape))
model.add(MaxPool3D(pool_size=(2, 2, 2)))
model.add(
Conv3D(64, kernel_size=(2, 2, 2), padding='same', activation='relu'))
model.add(MaxPool3D(pool_size=(2, 2, 2)))
model.add(
Conv3D(128, kernel_size=(2, 2, 2), padding='same', activation='relu'))
model.add(MaxPool3D(pool_size=(2, 2, 2)))
model.add(
Conv3D(256, kernel_size=(2, 2, 2), padding='same', activation='relu'))
model.add(MaxPool3D(pool_size=(2, 2, 2)))
model.add(
Conv3D(512, kernel_size=(2, 2, 2), padding='same', activation='relu'))
model.add(MaxPool3D(pool_size=(2, 2, 2)))
model.add(UpSampling3D(size=(2, 2, 2)))
model.add(
Deconv3D(512, kernel_size=(2, 2, 2), padding='same',
activation='relu'))
model.add(UpSampling3D(size=(2, 2, 2)))
model.add(
Deconv3D(256, kernel_size=(2, 2, 2), padding='same',
activation='relu'))
model.add(UpSampling3D(size=(2, 2, 2)))
model.add(
Deconv3D(128, kernel_size=(2, 2, 2), padding='same',
activation='relu'))
model.add(UpSampling3D(size=(2, 2, 2)))
model.add(
Deconv3D(64, kernel_size=(2, 2, 2), padding='same', activation='relu'))
model.add(UpSampling3D(size=(2, 2, 2)))
model.add(
Deconv3D(32, kernel_size=(2, 2, 2), padding='same', activation='relu'))
# model.add(Deconv3D(1, kernel_size=(2, 2, 2), padding='same', activation='relu'))
model.add(Dense(1))
# model.add(Lambda(lambda x: scale(x)))
model.compile(loss='mse',
metrics=[
keras.metrics.MeanIoU(num_classes=2),
tf.keras.metrics.MeanSquaredError()
],
optimizer='adam')
model.summary()
return model
def decoder(phase_train=True,
params={
'z_length': 200,
'strides': (2, 2, 2),
'kernel_size': (5, 5, 5)
}):
## Decoder, input z vector, output cube.
z_length = params['z_length']
strides = params['strides']
kernel_size = params['kernel_size']
inputs = Input(shape=(1, 1, 1, z_length))
dc1 = Deconv3D(filters=256,
kernel_size=kernel_size,
strides=(1, 1, 1),
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='valid')(inputs)
dc1 = BatchNormalization()(dc1, training=phase_train)
dc1 = Activation(activation='relu')(dc1)
dc2 = Deconv3D(filters=128,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(dc1)
dc2 = BatchNormalization()(dc2, training=phase_train)
dc2 = Activation(activation='relu')(dc2)
dc3 = Deconv3D(filters=64,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(dc2)
dc3 = BatchNormalization()(dc3, training=phase_train)
dc3 = Activation(activation='relu')(dc3)
dc4 = Deconv3D(filters=1,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(dc3)
dc4 = BatchNormalization()(dc4, training=phase_train)
dc4 = Activation(activation='sigmoid')(dc4)
model = Model(inputs=inputs, outputs=dc4)
model.summary()
return model
def build_generator(self):
model = Sequential()
# Encoder
model.add(
Conv3D(32,
kernel_size=5,
strides=2,
input_shape=self.vol_shape,
padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Conv3D(64, kernel_size=5, strides=2, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Conv3D(128, kernel_size=5, strides=2, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(BatchNormalization(momentum=0.8))
model.add(Conv3D(512, kernel_size=1, strides=2, padding="same"))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.5))
# Decoder
model.add(UpSampling3D())
model.add(Deconv3D(256, kernel_size=5, padding="same"))
model.add(Activation('relu'))
model.add(BatchNormalization(momentum=0.8))
model.add(Deconv3D(128, kernel_size=5, padding="same"))
model.add(Activation('relu'))
model.add(BatchNormalization(momentum=0.8))
model.add(UpSampling3D())
model.add(Deconv3D(64, kernel_size=5, padding="same"))
model.add(Activation('relu'))
model.add(BatchNormalization(momentum=0.8))
#
model.add(UpSampling3D())
#
model.add(Deconv3D(self.channels, kernel_size=5, padding="same"))
model.add(Activation('tanh'))
model.summary()
masked_vol = Input(shape=self.vol_shape)
gen_missing = model(masked_vol)
return Model(masked_vol, gen_missing)
def Create_Generator(self):
print(self.gen_input_shape)
input_layer = Input(shape = self.gen_input_shape)
a = Deconv3D(filters = self.gen_filters[0],
kernel_size = self.gen_kernel_size[0],
strides = self.gen_strides[0])(input_layer)
a = BatchNormalization()(a, training= True)
a = Activation(activation=self.gen_activations[0])(a)
for i in range(self.gen_convolution_blocks -1):
a = Deconv3D(filters = self.gen_filters[i + 1],
kernel_size = self.gen_kernel_size[i + 1],
strides = self.gen_strides[i + 1], padding='same')(a)
a = BatchNormalization()(a, training= True)
a = Activation(activation=self.gen_activations[i + 1])(a)
self.gen_model = Model(inputs=input_layer, outputs=a)
print(self.gen_model.summary())
return(self.gen_model)
def make_generator(self):
out = self.out_shape[0] * self.out_shape[1] * self.out_shape[2]
model = Sequential()
model.add(Deconv3D(filters=512, kernel_size=4, strides=1, kernel_initializer = 'glorot_normal', activation='relu',
input_shape=(1, 1, 1, 200), padding='valid'))
model.add(BatchNormalization())
model.add(Deconv3D(filters=256, kernel_size=4, strides=2, kernel_initializer = 'glorot_normal',
activation='relu', padding='same'))
model.add(BatchNormalization())
model.add(Deconv3D(filters=128, kernel_size=4, strides=2, kernel_initializer = 'glorot_normal',
activation='relu', padding='same'))
model.add(BatchNormalization())
model.add(Deconv3D(filters=64, kernel_size=4, strides=2, kernel_initializer = 'glorot_normal',
activation='relu', padding='same'))
model.add(Deconv3D(filters=1, kernel_size=4, strides=2, kernel_initializer = 'glorot_normal',
activation='relu', padding='same'))
model.add(Activation(activation='sigmoid'))
print(model.summary())
noise = Input(shape=(1,1,1,200))
img = model(noise)
return Model(noise, img)
def get_deconv_layer(input, num_filters):
a = Deconv3D(num_filters, kernel_size=(2, 2, 2), strides=(2, 2, 2))(input)
a = BatchNormalization(axis=1)(a)
return PReLU()(a)
def generator(trainable=True,
params={
'noise_size': 200,
'strides': (2, 2, 2),
'kernel_size': (4, 4, 4)
}):
"""
Returns a Generator Model
Args:
trainable (boolean): Should train the model or not
params (dict): Dictionary with model parameters
Returns:
model (keras.Model): Generator model
"""
noise_size = params['noise_size']
strides = params['strides']
kernel_size = params['kernel_size']
momentum = 0.9
dropout = 0.25
inputs = Input(shape=(1, 1, 1, noise_size))
generator_l1 = Deconv3D(filters=512,
kernel_size=kernel_size,
strides=(1, 1, 1),
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='valid')(inputs)
generator_l1 = BatchNormalization(momentum=momentum)(generator_l1,
training=trainable)
generator_l1 = Activation(activation='relu')(generator_l1)
generator_l1 = Dropout(dropout)(generator_l1)
generator_l2 = Deconv3D(filters=256,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(generator_l1)
generator_l2 = BatchNormalization(momentum=momentum)(generator_l2,
training=trainable)
generator_l2 = Activation(activation='relu')(generator_l2)
generator_l3 = Deconv3D(filters=128,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(generator_l2)
generator_l3 = BatchNormalization(momentum=momentum)(generator_l3,
training=trainable)
generator_l3 = Activation(activation='relu')(generator_l3)
generator_l4 = Deconv3D(filters=64,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(generator_l3)
generator_l4 = BatchNormalization(momentum=momentum)(generator_l4,
training=trainable)
generator_l4 = Activation(activation='relu')(generator_l4)
generator_l5 = Deconv3D(filters=1,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(generator_l4)
generator_l5 = BatchNormalization(momentum=momentum)(generator_l5,
training=trainable)
generator_l5 = Activation(activation='sigmoid')(generator_l5)
model = Model(inputs=inputs, outputs=generator_l5)
print("Generator")
model.summary()
return model
def build_model():
kernel_size = (4, 4, 4)
strides = (2, 2, 2)
model = Sequential()
model.add(
Conv3D(32,
kernel_size=(4, 4, 4),
strides=strides,
padding='same',
activation='relu',
input_shape=input_shape))
model.add(BatchNormalization())
model.add(
Conv3D(64,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(
Conv3D(128,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(
Conv3D(256,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(
Conv3D(512,
kernel_size=(2, 2, 2),
strides=1,
padding='same',
activation='relu'))
model.add(
Deconv3D(512,
kernel_size=(2, 2, 2),
strides=1,
padding='same',
activation='relu'))
model.add(
Deconv3D(256,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(
Deconv3D(128,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(
Deconv3D(64,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(
Deconv3D(32,
kernel_size=(2, 2, 2),
strides=strides,
padding='same',
activation='relu'))
model.add(BatchNormalization())
model.add(
Deconv3D(1,
kernel_size=(4, 4, 4),
strides=1,
padding='same',
activation='sigmoid'))
model.compile(loss='mse',
metrics=[
keras.metrics.MeanIoU(num_classes=2),
tf.keras.metrics.MeanSquaredError()
],
optimizer='adam')
model.summary()
return model
def generator(phase_train=True,
params={
'z_size': 200,
'strides': (2, 2, 2),
'kernel_size': (4, 4, 4)
}):
"""
Returns a Generator Model with input params and phase_train
Args:
phase_train (boolean): training phase or not
params (dict): Dictionary with model parameters
Returns:
model (keras.Model): Keras Generator model
"""
z_size = params['z_size']
strides = params['strides']
kernel_size = params['kernel_size']
inputs = Input(shape=(1, 1, 1, z_size))
g1 = Deconv3D(filters=512,
kernel_size=kernel_size,
strides=(1, 1, 1),
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='valid')(inputs)
g1 = BatchNormalization()(g1, training=phase_train)
g1 = Activation(activation='relu')(g1)
g2 = Deconv3D(filters=256,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(g1)
g2 = BatchNormalization()(g2, training=phase_train)
g2 = Activation(activation='relu')(g2)
g3 = Deconv3D(filters=128,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(g2)
g3 = BatchNormalization()(g3, training=phase_train)
g3 = Activation(activation='relu')(g3)
g4 = Deconv3D(filters=64,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(g3)
g4 = BatchNormalization()(g4, training=phase_train)
g4 = Activation(activation='relu')(g4)
g5 = Deconv3D(filters=1,
kernel_size=kernel_size,
strides=strides,
kernel_initializer='glorot_normal',
bias_initializer='zeros',
padding='same')(g4)
g5 = BatchNormalization()(g5, training=phase_train)
g5 = Activation(activation='sigmoid')(g5)
model = Model(inputs=inputs, outputs=g5)
model.summary()
return model
