def discriminator_loss(self, D, y, fake_y, use_lsgan=True, dy = True): """ Note: default: D(y).shape == (batch_size,5,5,1), fake_buffer_size=50, batch_size=1 Args: G: generator object D: discriminator object y: 4D tensor (batch_size, image_size, image_size, 3) Returns: loss: scalar """ # modify loss function to focus on ROI # add transformation loss # discriminator hint staff yw3025 if dy: # y discriminator y = tf.multiply(self.mask_y, y) fake_y = tf.multiply(self.mask_x, fake_y) else: # x discriminator y = tf.multiply(self.mask_x, y) fake_y = tf.multiply(self.mask_y, fake_y) if use_lsgan: # use mean squared error error_real = tf.reduce_mean(tf.squared_difference(D(y), REAL_LABEL)) error_fake = tf.reduce_mean(tf.square(D(fake_y))) else: # use cross entropy error_real = -tf.reduce_mean(ops.safe_log(D(y))) error_fake = -tf.reduce_mean(ops.safe_log(1-D(fake_y))) loss = (error_real + error_fake) / 2 return loss
def discriminator_loss(self, D, y, fake_y, use_lsgan=True): if use_lsgan: # use mean squared error# use mean squared error error_real = tf.reduce_mean(tf.squared_difference( D(y), REAL_LABEL)) error_fake = tf.reduce_mean(tf.square(D(fake_y))) else: error_real = -tf.reduce_mean(ops.safe_log(D(y))) error_fake = -tf.reduce_mean(ops.safe_log(1 - D(fake_y))) loss = (error_real + error_fake) / 2 return loss
def generator_loss(self, D, fake_y, use_lsgan=True): """Fool discriminator into believing that G(x) is real.""" if use_lsgan: # Use mean squared error loss = tf.reduce_mean(tf.squared_difference(D(fake_y), REAL_LABEL)) else: # heuristic, non-saturating loss loss = -tf.reduce_mean(ops.safe_log(D(fake_y))) / 2 return loss
def generator_loss(self, D, fake_y, use_lsgan=True): """ fool discriminator into believing that G(x) is real """ if use_lsgan: # use mean squared error loss = tf.reduce_mean(tf.squared_difference(D(fake_y), REAL_LABEL)) else: # heuristic, non-saturating loss loss = -tf.reduce_mean(ops.safe_log(D(fake_y))) / 2 return loss
def discriminator_loss(self, D, y, fake_y, use_lsgan=True): """ Note: default: D(y).shape == (batch_size,5,5,1), fake_buffer_size=50, batch_size=1 Args: G: generator object D: discriminator object y: 4D tensor (batch_size, image_size, image_size, 3) Returns: loss: scalar """ if use_lsgan: # use mean squared error error_real = tf.reduce_mean(tf.squared_difference(D(y), REAL_LABEL)) error_fake = tf.reduce_mean(tf.square(D(fake_y))) else: # use cross entropy error_real = -tf.reduce_mean(ops.safe_log(D(y))) error_fake = -tf.reduce_mean(ops.safe_log(1-D(fake_y))) loss = (error_real + error_fake) / 2 return loss
def conditioned_generator_loss(D, condition, fake_y, use_lsgan=True): """ fool discriminator into believing that G(x) is real """ if use_lsgan: # use mean squared error loss = tf.reduce_mean( tf.math.squared_difference(D(condition, fake_y), REAL_LABEL)) else: # heuristic, non-saturating loss loss = -tf.reduce_mean(ops.safe_log(D(condition, fake_y))) / 2 return loss
def discriminator_loss(self, D, y, fake_y, use_lsgan=True): """ Note: default: D(y).shape == (batch_size,5,5,1), fake_buffer_size=50, batch_size=1 Args: G: generator object D: discriminator object y: 4D tensor (batch_size, image_size, image_size, 3) Returns: loss: scalar """ if use_lsgan: # use mean squared error error_real = tf.reduce_mean(tf.squared_difference(D(y), REAL_LABEL)) error_fake = tf.reduce_mean(tf.square(D(fake_y))) else: # use cross entropy error_real = -tf.reduce_mean(ops.safe_log(D(y))) error_fake = -tf.reduce_mean(ops.safe_log(1-D(fake_y))) loss = (error_real + error_fake) / 2 return loss
def discriminator_loss(self, D, y, fake_y, use_lsgan=True): ''' Note: default: D(y).shape == (batch_size,5,5,1), fake_buffer_size=50, batch_size=1 :param D: discriminator object :param y: 4D tensor (batch_size, image_size, image_size, 3) :param fake_y: :param use_lsgan: :return: ''' if use_lsgan: # use mean squared error error_real = tf.reduce_mean(tf.squared_difference( D(y), REAL_LABEL)) error_fake = tf.reduce_mean(tf.square(D(fake_y))) else: error_real = -tf.reduce_mean(ops.safe_log(D(y))) error_fake = -tf.reduce_mean(ops.safe_log(1 - D(fake_y))) loss = (error_real + error_fake) / 2 return loss
def generator_loss(self, D_output_fake, gan_mode='lsgan', maxloss='mean'): """ fool discriminator into believing that G(x) is real """ if gan_mode == 'lsgan': if maxloss == 'mean': # use mean squared error loss = tf.reduce_mean( tf.squared_difference(D_output_fake, REAL_LABEL)) elif maxloss == 'max': # use max squared error loss = tf.reduce_max( tf.squared_difference(D_output_fake, REAL_LABEL)) elif maxloss == 'softmax': #use softmax squared error loss_map = (tf.squared_difference(D_output_fake, REAL_LABEL)) batchsize = loss_map.get_shape()[0].value reshaped_loss_map = tf.reshape(loss_map, shape=[batchsize, -1]) softmax_weight = tf.nn.softmax(reshaped_loss_map, dim=1) loss = tf.reduce_sum(softmax_weight * reshaped_loss_map) elif maxloss == 'focal': loss_map = (tf.squared_difference(D_output_fake, REAL_LABEL) + tf.square(D_output_fake)) / 2 loss_map_shape = loss_map.get_shape() D_output_fake_shape = D_output_fake.get_shape() prob_weight = (1 - D_output_fake) * 1.5 # here debug the prob coef print 'loss_map_shape:', loss_map_shape print 'D_output_fake_shape:', D_output_fake_shape loss = tf.reduce_mean(prob_weight * loss_map) elif gan_mode == 'lcgan': loss = tf.reduce_mean( tf.pow(tf.abs(tf.subtract(D_output_fake, REAL_LABEL)), 3)) elif gan_mode == 'gan': # heuristic, non-saturating loss loss = -tf.reduce_mean(ops.safe_log(D_output_fake)) / 2 elif gan_mode == 'gan_logits': if self.patchgan: constant05 = tf.constant(0.5, shape=(self.batch_size, 64)) loss = tf.reduce_mean( tf.losses.sigmoid_cross_entropy(constant05, D_output_fake)) else: constant05 = tf.constant(0.5, shape=(self.batch_size, 1)) loss = tf.reduce_mean( tf.losses.sigmoid_cross_entropy(constant05, D_output_fake)) elif gan_mode == 'wgangp': fake_result = D_output_fake g_loss = -tf.reduce_mean( fake_result) # This optimizes the generator. return g_loss else: print 'unknown gan mode %s' % gan_mode exit(0) return loss
def generator_loss(self, D, fake_y, use_lsgan=True): """ fool discriminator into believing that G(x) is real """ if use_lsgan: # use mean squared error # tf.squared_difference(x,y) # calculate the squared error between x and y loss = tf.reduce_mean(tf.squared_difference(D(fake_y), REAL_LABEL)) else: # heuristic, non-saturating loss loss = -tf.reduce_mean(ops.safe_log(D(fake_y))) / 2 return loss
def generator_loss(self, D, fake_y, use_lsgan=True): """ fool discriminator into believing that G(x) is real """ fake_y = self.segmentation.get_one_result(fake_y)*y if use_lsgan: # use mean squared error loss = tf.reduce_mean(tf.squared_difference(D(fake_y), REAL_LABEL)) else: # heuristic, non-saturating loss loss = -tf.reduce_mean(ops.safe_log(D(fake_y))) / 2 return loss
def generator_loss(self, D, fake_y, use_lsgan=True): if use_lsgan: loss = tf.reduce_mean(tf.squared_difference(D(fake_y), REAL_LABEL)) else: loss = -tf.reduce_mean(ops.safe_log(D(fake_y))) / 2 return loss
def discriminator_loss(self, D, D_output_fake, D_output_real, fake, real, gan_mode='lsgan', maxloss='mean'): """ Note: default: D(y).shape == (batch_size,5,5,1), fake_buffer_size=50, batch_size=1 Args: G: generator object D: discriminator object y: 4D tensor (batch_size, image_size, image_size, 3) Returns: loss: scalar """ if gan_mode == 'lsgan': if maxloss == 'mean': # use mean squared error error_real = tf.reduce_mean( tf.squared_difference(D_output_real, REAL_LABEL)) error_fake = tf.reduce_mean(tf.square(D_output_fake)) elif maxloss == 'max': # use max squared error error_real = tf.reduce_max( tf.squared_difference(D_output_real, REAL_LABEL)) error_fake = tf.reduce_max(tf.square(D_output_fake)) ''' elif maxloss == 'softmax': loss_map = (tf.squared_difference(D_output_real, REAL_LABEL) + tf.square(D_output_fake)) / 2 loss_map_shape = loss_map.get_shape() reshaped_loss_map = tf.reshape(loss_map, shape=[loss_map_shape[0], -1]) softmax_weight = tf.nn.softmax(reshaped_loss_map, dim=1) error = tf.reduce_sum(softmax_weight * reshaped_loss_map) loss = error / 2 return loss ''' elif gan_mode == 'lcgan': # use mean cubic error error_real = tf.reduce_mean( tf.pow(tf.abs(tf.subtract(D_output_real, REAL_LABEL)), 3)) error_fake = tf.reduce_mean(tf.pow(tf.abs(D_output_fake), 3)) elif gan_mode == 'gan': # use cross entropy error_real = -tf.reduce_mean(ops.safe_log(D_output_real)) error_fake = -tf.reduce_mean(ops.safe_log(1 - D_output_fake)) elif gan_mode == 'gan_logits': if self.patchgan: constant08 = tf.constant(0.8, shape=(self.batch_size, 64)) constant02 = tf.constant(0.2, shape=(self.batch_size, 64)) error_real = tf.reduce_mean( tf.losses.sigmoid_cross_entropy(constant08, D_output_real)) error_fake = tf.reduce_mean( tf.losses.sigmoid_cross_entropy(constant02, D_output_fake)) else: constant08 = tf.constant(0.8, shape=(self.batch_size, 1)) constant02 = tf.constant(0.2, shape=(self.batch_size, 1)) error_real = tf.reduce_mean( tf.losses.sigmoid_cross_entropy(constant08, D_output_real)) error_fake = tf.reduce_mean( tf.losses.sigmoid_cross_entropy(constant02, D_output_fake)) elif gan_mode == 'wgangp': alpha = tf.random_uniform(shape=[self.batch_size, 1], minval=0., maxval=1.) real_result = D_output_real fake_result = D_output_fake d_loss = tf.reduce_mean( fake_result - real_result) # This optimizes the discriminator. differences = fake - real interpolates = real + tf.multiply(alpha, differences) gradients = tf.gradients(D(interpolates), [interpolates])[0] slopes = tf.sqrt( tf.reduce_sum(tf.square(gradients), reduction_indices=[3])) gradient_penalty = tf.reduce_mean((slopes - 1.)**2) d_loss += LAMBDA * gradient_penalty return d_loss else: print 'unknown gan mode %s' % gan_mode exit(0) loss = (error_real + error_fake) / 2 return loss