def build_model(self): # Placeholders for real training samples self.input_A_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_real') self.input_A2_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_real') self.input_B_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_real') self.input_C_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_real') # Placeholders for label of real training samples self.input_A_label = tf.placeholder(tf.float32, shape=self.label_shape, name='input_A_label') self.input_B_label = tf.placeholder(tf.float32, shape=self.label_shape, name='input_B_label') self.input_C_label = tf.placeholder(tf.float32, shape=self.label_shape, name='input_C_label') # placeholders for alpha self.rnd = tf.placeholder(tf.float32, []) self.alpha = tf.placeholder(tf.float32, shape=[None]) self.alpha_1 = tf.reshape(self.alpha, [-1, 1]) # Placeholders for fake generated samples self.input_A_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_fake') self.input_B_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_fake') # Placeholders for cycle generated samples self.input_A_cycle = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_cycle') self.input_B_cycle = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_cycle') # Placeholder for test samples self.input_A_test = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_test') self.vector_A2B = self.input_B_label - self.input_A_label self.vector_C2B = self.input_B_label - self.input_C_label self.vector_A2C = self.input_C_label - self.input_A_label self.lambda_conditional = 1 self.lambda_interp = 10 #self.lambda_forward = 10 self.lambda_backward = tf.placeholder(tf.float32, None, name='lambda_backward') self.lambda_triangle = tf.placeholder(tf.float32, None, name='lambda_triangle') self.lambda_mode_seeking = 1 self.generation_B = self.generator(inputs=self.input_A_real, vec=self.vector_A2B, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=False, scope_name='generator_A2B') self.generation_B2 = self.generator(inputs=self.input_A2_real, vec=self.vector_A2B, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') self.cycle_A = self.generator(inputs=self.generation_B, vec=-self.vector_A2B, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') self.generation_A_identity = self.generator(inputs=self.input_A_real, vec=self.vector_A2B-self.vector_A2B, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') self.generation_alp = self.generator(inputs=self.input_A_real, vec=self.vector_A2B*self.alpha_1, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') #self.generation_alp_forward = self.generator(inputs=self.generation_alp, vec=self.vector_A2B*(1-self.alpha_1), # num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, # reuse=True, # scope_name='generator_A2B') self.generation_alp_backward = self.generator(inputs=self.generation_alp, vec=-self.vector_A2B*self.alpha_1, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') self.generation_C = self.generator(inputs=self.generation_B, vec=-self.vector_C2B, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') self.generation_A = self.generator(inputs=self.generation_C, vec=-self.vector_A2C, num_domains=self.num_domains, dim=self.num_features, batch_size=self.batch_size, reuse=True, scope_name='generator_A2B') # One-step discriminator self.discrimination_B_fake = self.discriminator(inputs_A=self.generation_B, inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[False,False], scope_name='discriminator_B', method='adversarial') self.discrimination_alp_fake = self.discriminator(inputs_A=self.generation_alp, inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='adversarial') # Two-step discriminator self.discrimination_A_dot_fake = self.discriminator(inputs_A=self.cycle_A, inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='adversarial') # Cycle loss self.cycle_loss = l1_loss(y=self.input_A_real, y_hat=self.cycle_A) # Identity loss self.identity_loss = l1_loss(y=self.input_A_real, y_hat=self.generation_A_identity) # Forward loss #self.forward_loss = l1_loss(y=self.generation_B, y_hat=self.generation_alp_forward) # Backward loss self.backward_loss = l1_loss(y=self.input_A_real, y_hat=self.generation_alp_backward) # Mode seeking Loss self.mode_seeking_loss = tf.divide(l1_loss(y=self.input_A_real, y_hat=self.input_A2_real), l1_loss(y=self.generation_B, y_hat=self.generation_B2)+1e-12) # Triangle Loss self.triangle_loss = l1_loss(y=self.input_A_real, y_hat=self.generation_A) # Place holder for lambda_cycle and lambda_identity self.lambda_cycle = tf.placeholder(tf.float32, None, name='lambda_cycle') self.lambda_identity = tf.placeholder(tf.float32, None, name='lambda_identity') # ------------------------------- Generator and Discriminator loss # Generator wants to fool discriminator self.generator_loss_A2B = l2_loss(y=tf.ones_like(self.discrimination_B_fake), y_hat=self.discrimination_B_fake) #+ l2_loss(y=tf.ones_like(self.discrimination_alp_fake), y_hat=self.discrimination_alp_fake) #self.generator_loss_alp = # Two-step generator loss self.two_step_generator_loss_A = l2_loss(y=tf.ones_like(self.discrimination_A_dot_fake), y_hat=self.discrimination_A_dot_fake) # One-step self.discrimination_input_B_real = self.discriminator(inputs_A=self.input_B_real, inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='adversarial') self.discrimination_input_B_fake = self.discriminator(inputs_A=self.input_B_fake, inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='adversarial') # Two-step self.discrimination_input_A_dot_real = self.discriminator(inputs_A=self.input_A_real,inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='adversarial') self.discrimination_input_A_dot_fake = self.discriminator(inputs_A=self.input_A_cycle, inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='adversarial') # Discriminator wants to classify real and fake correctly self.discriminator_loss_input_B_real = l2_loss(y=tf.ones_like(self.discrimination_input_B_real), y_hat=self.discrimination_input_B_real) self.discriminator_loss_input_B_fake = l2_loss(y=tf.zeros_like(self.discrimination_input_B_fake), y_hat=self.discrimination_input_B_fake) self.discriminator_loss_alp = l2_loss(y=tf.zeros_like(self.discrimination_alp_fake), y_hat=self.discrimination_alp_fake) self.discriminator_loss_B = (self.discriminator_loss_input_B_real + self.discriminator_loss_input_B_fake) / 2 #self.discriminator_loss_B = (self.discriminator_loss_input_B_real + self.discriminator_loss_input_B_fake + self.discriminator_loss_alp) / 3 # Two-step discriminator loss #self.two_step_discriminator_loss_input_A_real = l2_loss(y=tf.ones_like(self.discrimination_input_A_dot_real), # y_hat=self.discrimination_input_A_dot_real) #self.two_step_discriminator_loss_input_A_fake = l2_loss(y=tf.zeros_like(self.discrimination_input_A_dot_fake), # y_hat=self.discrimination_input_A_dot_fake) #self.two_step_discriminator_loss_A = (self.two_step_discriminator_loss_input_A_real + # self.two_step_discriminator_loss_input_A_fake) / 2 # Conditional adversarial Loss self.sr = self.discriminator(inputs_A=self.input_A_real,inputs_B=self.input_B_real,vec=self.vector_A2B, num_domains=self.num_domains, reuse=[True,False], scope_name='discriminator_B', method='matching') self.sf = self.discriminator(inputs_A=self.input_A_real,inputs_B=self.generation_B,vec=self.vector_A2B, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='matching') self.w1 = self.discriminator(inputs_A=self.input_C_real,inputs_B=self.input_B_real,vec=self.vector_A2B, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='matching') self.w2 = self.discriminator(inputs_A=self.input_A_real,inputs_B=self.input_B_real,vec=self.vector_C2B, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='matching') self.w3 = self.discriminator(inputs_A=self.input_A_real,inputs_B=self.input_B_real,vec=self.vector_A2C, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='matching') self.w4 = self.discriminator(inputs_A=self.input_A_real,inputs_B=self.input_C_real,vec=self.vector_A2B, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='matching') self.discriminator_loss_conditional_sr = l2_loss(y=tf.ones_like(self.sr), y_hat=self.sr) self.discriminator_loss_conditional_sf = l2_loss(y=tf.zeros_like(self.sf), y_hat=self.sf) self.discriminator_loss_conditional_w1 = l2_loss(y=tf.zeros_like(self.w1), y_hat=self.w1) self.discriminator_loss_conditional_w2 = l2_loss(y=tf.zeros_like(self.w2), y_hat=self.w2) self.discriminator_loss_conditional_w3 = l2_loss(y=tf.zeros_like(self.w3), y_hat=self.w3) self.discriminator_loss_conditional_w4 = l2_loss(y=tf.zeros_like(self.w4), y_hat=self.w4) self.discriminator_loss_conditional = self.discriminator_loss_conditional_sr + self.discriminator_loss_conditional_sf + \ self.discriminator_loss_conditional_w1 + self.discriminator_loss_conditional_w2 + \ self.discriminator_loss_conditional_w3 + self.discriminator_loss_conditional_w4 self.generator_loss_conditional_sf = l2_loss(y=tf.ones_like(self.sf), y_hat=self.sf) # Interpolation Loss self.interpolate_identity = self.discriminator(inputs_A=self.generation_A_identity,inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,False], scope_name='discriminator_B', method='interpolation') self.interpolate_B = self.discriminator(inputs_A=self.generation_B,inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='interpolation') self.interpolate_alp = self.discriminator(inputs_A=self.generation_alp,inputs_B=None,vec=None, num_domains=self.num_domains, reuse=[True,True], scope_name='discriminator_B', method='interpolation') self.discriminator_loss_interp_AB = l2_loss(y=tf.zeros_like(self.interpolate_identity), y_hat=self.interpolate_identity) if self.rnd==0 else l2_loss(y=tf.zeros_like(self.interpolate_B), y_hat=self.interpolate_B) #print(self.alpha_1<0.5) #print(self.interpolate_identity) #self.discriminator_loss_interp_AB = tf.where(self.alpha_1<0.5,self.interpolate_identity, self.interpolate_B) self.discriminator_loss_interp_alp = l2_loss(y=tf.ones_like(self.interpolate_alp)*tf.reshape(self.alpha_1,[-1,1,1,1]), y_hat=self.interpolate_alp) if self.rnd==0 else l2_loss(y=tf.ones_like(self.interpolate_alp)*tf.reshape(1-self.alpha_1,[-1,1,1,1]), y_hat=self.interpolate_alp) #self.discriminator_loss_interp_alp = tf.where(self.alpha_1<0.5,l2_loss(y=tf.ones_like(self.interpolate_alp)*tf.reshape(self.alpha_1,[-1,1,1,1]), y_hat=self.interpolate_alp),l2_loss(y=tf.ones_like(self.interpolate_alp)*tf.reshape(1-self.alpha_1,[-1,1,1,1]), y_hat=self.interpolate_alp)) self.discriminator_loss_interp = self.discriminator_loss_interp_AB + self.discriminator_loss_interp_alp self.generator_loss_interp_alp = l2_loss(y=tf.zeros_like(self.interpolate_alp), y_hat=self.interpolate_alp) # Merge the generator losses self.generator_loss = self.generator_loss_A2B + self.lambda_backward * self.backward_loss + self.mode_seeking_loss + \ self.lambda_cycle * self.cycle_loss + self.lambda_identity * self.identity_loss + self.lambda_triangle*self.triangle_loss + \ self.lambda_conditional * self.generator_loss_conditional_sf + self.lambda_interp * self.generator_loss_interp_alp #self.generator_loss = self.lambda_identity * self.identity_loss # Merge the discriminator Losses self.discriminator_loss = self.discriminator_loss_B + \ self.lambda_interp * self.discriminator_loss_interp + self.lambda_conditional * self.discriminator_loss_conditional #self.discriminator_loss = self.discriminator_loss_B # Categorize variables because we have to optimize the two sets of the variables separately trainable_variables = tf.trainable_variables() self.discriminator_vars = [var for var in trainable_variables if 'discriminator' in var.name] self.generator_vars = [var for var in trainable_variables if 'generator' in var.name] # for var in t_vars: print(var.name) # Reserved for test self.generation_B_test = self.generator(inputs=self.input_A_test, vec=self.vector_A2B*self.alpha_1, num_domains=self.num_domains, dim=self.num_features, batch_size=1, reuse=True, scope_name='generator_A2B')
def build_model(self): # Placeholders for real training samples self.input_A_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_real') self.input_B_real = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_real') # Placeholders for fake generated samples self.input_A_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_fake') self.input_B_fake = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_fake') # Placeholder for test samples self.input_A_test = tf.placeholder(tf.float32, shape=self.input_shape, name='input_A_test') self.input_B_test = tf.placeholder(tf.float32, shape=self.input_shape, name='input_B_test') self.generation_B = self.generator(inputs=self.input_A_real, dim=self.num_features, reuse=False, scope_name='generator_A2B') self.cycle_A = self.generator(inputs=self.generation_B, dim=self.num_features, reuse=False, scope_name='generator_B2A') self.generation_A = self.generator(inputs=self.input_B_real, dim=self.num_features, reuse=True, scope_name='generator_B2A') self.cycle_B = self.generator(inputs=self.generation_A, dim=self.num_features, reuse=True, scope_name='generator_A2B') self.generation_A_identity = self.generator(inputs=self.input_A_real, dim=self.num_features, reuse=True, scope_name='generator_B2A') self.generation_B_identity = self.generator(inputs=self.input_B_real, dim=self.num_features, reuse=True, scope_name='generator_A2B') self.discrimination_A_fake = self.discriminator( inputs=self.generation_A, reuse=False, scope_name='discriminator_A') self.discrimination_B_fake = self.discriminator( inputs=self.generation_B, reuse=False, scope_name='discriminator_B') # Cycle loss self.cycle_loss = l1_loss(y=self.input_A_real, y_hat=self.cycle_A) + l1_loss( y=self.input_B_real, y_hat=self.cycle_B) # Identity loss self.identity_loss = l1_loss( y=self.input_A_real, y_hat=self.generation_A_identity) + l1_loss( y=self.input_B_real, y_hat=self.generation_B_identity) # Place holder for lambda_cycle and lambda_identity self.lambda_cycle = tf.placeholder(tf.float32, None, name='lambda_cycle') self.lambda_identity = tf.placeholder(tf.float32, None, name='lambda_identity') # Generator loss # Generator wants to fool discriminator self.generator_loss_A2B = l2_loss(y=tf.ones_like( self.discrimination_B_fake), y_hat=self.discrimination_B_fake) self.generator_loss_B2A = l2_loss(y=tf.ones_like( self.discrimination_A_fake), y_hat=self.discrimination_A_fake) # Merge the two generators and the cycle loss self.generator_loss = self.generator_loss_A2B + self.generator_loss_B2A + self.lambda_cycle * self.cycle_loss + self.lambda_identity * self.identity_loss # Discriminator loss self.discrimination_input_A_real = self.discriminator( inputs=self.input_A_real, reuse=True, scope_name='discriminator_A') self.discrimination_input_B_real = self.discriminator( inputs=self.input_B_real, reuse=True, scope_name='discriminator_B') self.discrimination_input_A_fake = self.discriminator( inputs=self.input_A_fake, reuse=True, scope_name='discriminator_A') self.discrimination_input_B_fake = self.discriminator( inputs=self.input_B_fake, reuse=True, scope_name='discriminator_B') # Discriminator wants to classify real and fake correctly self.discriminator_loss_input_A_real = l2_loss( y=tf.ones_like(self.discrimination_input_A_real), y_hat=self.discrimination_input_A_real) self.discriminator_loss_input_A_fake = l2_loss( y=tf.zeros_like(self.discrimination_input_A_fake), y_hat=self.discrimination_input_A_fake) self.discriminator_loss_A = (self.discriminator_loss_input_A_real + self.discriminator_loss_input_A_fake) / 2 self.discriminator_loss_input_B_real = l2_loss( y=tf.ones_like(self.discrimination_input_B_real), y_hat=self.discrimination_input_B_real) self.discriminator_loss_input_B_fake = l2_loss( y=tf.zeros_like(self.discrimination_input_B_fake), y_hat=self.discrimination_input_B_fake) self.discriminator_loss_B = (self.discriminator_loss_input_B_real + self.discriminator_loss_input_B_fake) / 2 # Merge the two discriminators into one self.discriminator_loss = self.discriminator_loss_A + self.discriminator_loss_B # Categorize variables because we have to optimize the two sets of the variables separately trainable_variables = tf.trainable_variables() self.discriminator_vars = [ var for var in trainable_variables if 'discriminator' in var.name ] self.generator_vars = [ var for var in trainable_variables if 'generator' in var.name ] # for var in t_vars: print(var.name) # Reserved for test self.generation_B_test = self.generator(inputs=self.input_A_test, dim=self.num_features, reuse=True, scope_name='generator_A2B') self.generation_A_test = self.generator(inputs=self.input_B_test, dim=self.num_features, reuse=True, scope_name='generator_B2A')