def build_tensorflow_model(self, batch_size):
""" Break it out into functions?
"""
# Set input/output shapes for reference during inference.
self.model_input_shape = tuple([batch_size] + list(self.input_shape))
self.model_output_shape = tuple([batch_size] + list(self.input_shape))
self.latent = tf.placeholder(tf.float32, [None, self.latent_size])
self.reference_images = tf.placeholder(
tf.float32, [None] + list(self.model_input_shape)[1:])
self.synthetic_images = generator(self,
self.latent,
depth=self.depth,
name='generator')
self.discriminator_real, self.discriminator_real_logits = discriminator(
self,
self.reference_images,
depth=self.depth + 1,
name='discriminator')
self.discriminator_fake, self.discriminator_fake_logits = discriminator(
self,
self.synthetic_images,
depth=self.depth + 1,
name='discriminator',
reuse=True)
t_vars = tf.trainable_variables()
self.d_vars = [var for var in t_vars if 'discriminator' in var.name]
self.g_vars = [var for var in t_vars if 'generator' in var.name]
self.saver = tf.train.Saver(self.g_vars + self.d_vars)
self.calculate_losses()
if self.hyperverbose:
self.model_summary()
def build_tensorflow_model(self, batch_size):
""" Break it out into functions?
"""
# Set input/output shapes for reference during inference.
self.model_input_shape = tuple([batch_size] + list(self.input_shape))
self.model_output_shape = tuple([batch_size] + list(self.input_shape))
self.alpha_transition = tf.Variable(initial_value=0.0,
trainable=False,
name='alpha_transition')
self.step_pl = tf.placeholder(tf.float32, shape=None)
self.alpha_transition_assign = self.alpha_transition.assign(
self.step_pl / (self.num_epochs * self.training_steps_per_epoch))
self.latent = tf.placeholder(tf.float32, [None, self.latent_size])
self.reference_images = tf.placeholder(
tf.float32, [None] + list(self.model_input_shape)[1:])
self.synthetic_images = generator(
self,
self.latent,
depth=self.progressive_depth,
transition=self.transition,
alpha_transition=self.alpha_transition,
name='generator')
# Derived Parameters
self.output_size = pow(2, self.progressive_depth + 2)
self.zoom_level = self.progressive_depth + 1
self.reference_images = tf.placeholder(
tf.float32,
[None] + [self.output_size] * self.dim + [self.channels])
max_downscale = np.floor(math.log(self.model_input_shape[1], 2))
downscale_factor = 2**max_downscale / (2**(self.progressive_depth + 2))
self.raw_volumes = tf.placeholder(tf.float32, self.model_input_shape)
self.input_volumes = downscale2d(self.raw_volumes, downscale_factor)
# Data Loading Tools
self.low_images = upscale2d(downscale2d(self.reference_images, 2), 2)
self.real_images = self.alpha_transition * self.reference_images + (
1 - self.alpha_transition) * self.low_images
self.discriminator_real, self.discriminator_real_logits = discriminator(
self,
self.reference_images,
depth=self.progressive_depth,
name='discriminator',
transition=self.transition,
alpha_transition=self.alpha_transition)
self.discriminator_fake, self.discriminator_fake_logits = discriminator(
self,
self.synthetic_images,
depth=self.progressive_depth,
name='discriminator',
transition=self.transition,
alpha_transition=self.alpha_transition,
reuse=True)
# Hmmm.. better way to do this? Or at least move to function.
t_vars = tf.trainable_variables()
self.d_vars = [var for var in t_vars if 'discriminator' in var.name]
self.g_vars = [var for var in t_vars if 'generator' in var.name]
# save the variables , which remain unchanged
self.d_vars_n = [
var for var in self.d_vars if 'discriminator_n' in var.name
]
self.g_vars_n = [
var for var in self.g_vars if 'generator_n' in var.name
]
# remove the new variables for the new model
self.d_vars_n_read = [
var for var in self.d_vars_n
if '{}'.format(self.output_size) not in var.name
]
self.g_vars_n_read = [
var for var in self.g_vars_n
if '{}'.format(self.output_size) not in var.name
]
# save the rgb variables, which remain unchanged
self.d_vars_n_2 = [
var for var in self.d_vars
if 'discriminator_y_rgb_conv' in var.name
]
self.g_vars_n_2 = [
var for var in self.g_vars if 'generator_y_rgb_conv' in var.name
]
self.d_vars_n_2_rgb = [
var for var in self.d_vars_n_2
if '{}'.format(self.output_size) not in var.name
]
self.g_vars_n_2_rgb = [
var for var in self.g_vars_n_2
if '{}'.format(self.output_size) not in var.name
]
self.saver = tf.train.Saver(self.d_vars + self.g_vars)
self.r_saver = tf.train.Saver(self.d_vars_n_read + self.g_vars_n_read)
if len(self.d_vars_n_2_rgb + self.g_vars_n_2_rgb):
self.rgb_saver = tf.train.Saver(self.d_vars_n_2_rgb +
self.g_vars_n_2_rgb)
self.calculate_losses()
if self.hyperverbose:
self.model_summary()
def build_tensorflow_model(self, batch_size):
""" Break it out into functions?
"""
# Set input/output shapes for reference during inference.
self.model_input_shape = tuple([batch_size] + list(self.input_shape))
self.model_output_shape = tuple([batch_size] + list(self.input_shape))
self.latent = tf.placeholder(tf.float32, [None, self.latent_size])
self.reference_images = tf.placeholder(tf.float32, [None] + list(self.model_input_shape)[1:])
self.synthetic_images = generator(self, self.latent, depth=self.depth, name='generator')
_, _, _, self.discriminator_real_logits = discriminator(self, self.reference_images, depth=self.depth + 1, name='discriminator')
_, _, _, self.discriminator_fake_logits = discriminator(self, self.synthetic_images, depth=self.depth + 1, name='discriminator', reuse=True)
self.basic_loss = tf.reduce_mean(tf.square(self.reference_images - self.synthetic_images))
# Loss functions
self.D_loss = tf.reduce_mean(self.discriminator_fake_logits) - tf.reduce_mean(self.discriminator_real_logits)
self.G_loss = -tf.reduce_mean(self.discriminator_fake_logits)
# Gradient Penalty from Wasserstein GAN GP, I believe? Check on it --andrew
# Also investigate more what's happening here --andrew
self.differences = self.synthetic_images - self.reference_images
self.alpha = tf.random_uniform(shape=[tf.shape(self.differences)[0], 1, 1, 1], minval=0., maxval=1.)
interpolates = self.reference_images + (self.alpha * self.differences)
_, _, _, discri_logits = discriminator(self, interpolates, reuse=True, depth=self.depth + 1, name='discriminator')
gradients = tf.gradients(discri_logits, [interpolates])[0]
# Some sort of norm from papers, check up on it. --andrew
slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2, 3]))
self.gradient_penalty = tf.reduce_mean((slopes - 1.) ** 2)
tf.summary.scalar("gp_loss", self.gradient_penalty)
# Update Loss functions..
self.D_origin_loss = self.D_loss
self.D_loss += 10 * self.gradient_penalty
self.D_loss += 0.001 * tf.reduce_mean(tf.square(self.discriminator_real_logits - 0.0))
# vgg_model = tf.keras.applications.VGG19(include_top=False,
# weights='imagenet',
# input_tensor=self.synthetic_images,
# input_shape=(64, 64, 3),
# pooling=None,
# classes=1000)
# print(vgg_model)
# self.load_reference_model()
input_tensor = keras.layers.Input(tensor=self.synthetic_images, shape=self.input_shape)
model_parameters = {'input_shape': self.input_shape,
'downsize_filters_factor': 1,
'pool_size': (2, 2),
'kernel_size': (3, 3),
'dropout': 0,
'batch_norm': True,
'initial_learning_rate': 0.00001,
'output_type': 'binary_label',
'num_outputs': 1,
'activation': 'relu',
'padding': 'same',
'implementation': 'keras',
'depth': 3,
'max_filter': 128,
'stride_size': (1, 1),
'input_tensor': input_tensor}
unet_output = UNet(**model_parameters)
unet_model = keras.models.Model(input_tensor, unet_output.output_layer)
unet_model.load_weights('retinal_seg_weights.h5')
if self.hyperverbose:
self.model_summary()
# self.find_layers(['sampling'])
self.activated_tensor = self.grab_tensor(self.activated_tensor_name)
print self.activated_tensor
self.activated_tensor = tf.stack([self.activated_tensor[..., self.filter_num]], axis=-1)
print self.activated_tensor
# self.input_tensor = self.grab_tensor(self.input_tensor_name)
self.activation_loss = -1 * tf.reduce_mean(self.activated_tensor)
self.activaton_graidents = tf.gradients(self.activation_loss, self.synthetic_images)
print self.activaton_graidents
# Hmmm.. better way to do this? Or at least move to function.
t_vars = tf.trainable_variables()
self.d_vars = [var for var in t_vars if 'discriminator' in var.name]
self.g_vars = [var for var in t_vars if 'generator' in var.name]
# Create save/load operation
self.saver = tf.train.Saver(self.g_vars + self.d_vars)
self.G_activation_loss = self.G_loss + .000 * self.activation_loss
# Create Optimizers
self.opti_D = tf.train.AdamOptimizer(learning_rate=self.initial_learning_rate, beta1=0.0, beta2=0.99).minimize(
self.D_loss, var_list=self.d_vars)
self.opti_G = self.tensorflow_optimizer_dict[self.optimizer](learning_rate=self.initial_learning_rate, beta1=0.0, beta2=0.99).minimize(self.G_activation_loss, var_list=self.g_vars)
self.combined_loss = 1 * self.activation_loss + 1 * self.basic_loss
self.combined_optimizer = self.tensorflow_optimizer_dict[self.optimizer](learning_rate=self.initial_learning_rate, beta1=0.0, beta2=0.99).minimize(self.combined_loss, var_list=self.g_vars)
self.basic_optimizer = self.tensorflow_optimizer_dict[self.optimizer](learning_rate=self.initial_learning_rate, beta1=0.0, beta2=0.99).minimize(self.basic_loss, var_list=self.g_vars)
self.activation_optimizer = self.tensorflow_optimizer_dict[self.optimizer](learning_rate=self.initial_learning_rate, beta1=0.0, beta2=0.99).minimize(self.activation_loss, var_list=self.g_vars)