def generative_model(self, batch, additional_inputs_tf): self.gen_epoch = additional_inputs_tf[0] self.gen_b_identity = additional_inputs_tf[1] if len(batch['observed']['properties']['flat'])>0: for e in batch['observed']['properties']['flat']: e['dist']='dirac' else: for e in batch['observed']['properties']['image']: e['dist']='dirac' self.gen_input_sample = batch['observed']['data'] self.gen_input_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.gen_input_sample) try: self.n_time = batch['observed']['properties']['flat'][0]['size'][1] except: self.n_time = batch['observed']['properties']['image'][0]['size'][1] try: self.gen_batch_size_tf = tf.shape(self.input_sample['flat'])[0] except: self.gen_batch_size_tf = tf.shape(self.input_sample['image'])[0] self.gen_pre_prior_param = self.PriorMap.forward((tf.zeros(shape=(self.gen_batch_size_tf, 1)),)) self.gen_pre_prior_dist = distributions.DiagonalGaussianDistribution(params = self.gen_pre_prior_param) self.gen_pre_prior_latent_code = self.gen_pre_prior_dist.sample() self.gen_pre_prior_latent_code_log_pdf = self.gen_pre_prior_dist.log_pdf(self.gen_pre_prior_latent_code) self.gen_flow_param_list = self.FlowMap.forward() self.gen_flow_object = transforms.SerialFlow([\ transforms.NonLinearIARFlow(self.gen_flow_param_list[0], self.config['n_latent']), transforms.NonLinearIARFlow(self.gen_flow_param_list[1], self.config['n_latent']), transforms.NonLinearIARFlow(self.gen_flow_param_list[2], self.config['n_latent']), transforms.NonLinearIARFlow(self.gen_flow_param_list[3], self.config['n_latent']), transforms.NonLinearIARFlow(self.gen_flow_param_list[4], self.config['n_latent']), ]) self.gen_prior_latent_code, self.gen_prior_latent_code_log_pdf = self.gen_flow_object.inverse_transform(self.gen_pre_prior_latent_code, self.gen_pre_prior_latent_code_log_pdf) self.gen_obs_sample_param = self.Generator.forward(self.gen_prior_latent_code[:, np.newaxis, :]) self.gen_obs_sample_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.gen_obs_sample_param) self.gen_obs_sample = self.gen_obs_sample_dist.sample(b_mode=True)
else: flow_parameters_list[i] = 1*tf.layers.dense(inputs = flow_param_input, units = curr_flow_class.required_num_parameters(n_dim), use_bias = True, activation = None) serial_flow_list = [] for j in range(batch_size_np): normalizing_flow_list = [] for i in range(len(flow_class_list)): curr_param = None if flow_parameters_list[i] is not None: curr_param = flow_parameters_list[i][j, np.newaxis, :] curr_flow_class = flow_class_list[i] normalizing_flow_list.append(curr_flow_class(input_dim=n_dim, parameters=curr_param)) if curr_flow_class == transforms.NonLinearIARFlow: normalizing_flow_list.append(transforms.GeneralInverseFlow(transform=normalizing_flow_list[-2])) serial_flow_list.append(transforms.SerialFlow(normalizing_flow_list)) ################################################################################################################################################################ def nonlinear_pixel_transformation_clousure(batch_input_pixels, b_inverse=False): # input = [tf.shape(input_pixels)[0] (corresponding the individual pixels in a grid of output image), 2] # output = [batch_size_tf, 2, tf.shape(input_pixels)[0]] # serial_flow does not allow different transformations for each image in the batch # See the note in linear_pixel_transformation_clousure for understanding the transformation. output_pixels_list = [] for j in range(batch_size_np): if b_inverse: curr_output_pixels, _ = serial_flow_list[j].inverse_transform(batch_input_pixels[j,:,:], None) else: curr_output_pixels, _ = serial_flow_list[j].transform(batch_input_pixels[j,:,:], None) output_pixels_list.append(curr_output_pixels[np.newaxis,:,:])
units=flow_class_1.required_num_parameters(n_dim), use_bias=False, activation=None) normalizing_flow_list.append( flow_class_1(input_dim=n_dim, parameters=flow_class_1_parameters)) flow_class_2_parameters = None if flow_class_2.required_num_parameters(n_dim) > 0: flow_class_2_parameters = 1 * tf.layers.dense( inputs=tf.ones(shape=(1, 1)), units=flow_class_2.required_num_parameters(n_dim), use_bias=False, activation=None) normalizing_flow_list.append( flow_class_2(input_dim=n_dim, parameters=flow_class_2_parameters)) serial_flow = transforms.SerialFlow(normalizing_flow_list) start_mean = tf.zeros(shape=(batch_size_tf, n_dim)) start_log_var = tf.log(tf.ones(shape=(batch_size_tf, n_dim)) * 1) start_dist = distributions.DiagonalGaussianDistribution( params=tf.concat([start_mean, start_log_var], axis=1)) x_log_pdf = start_dist.log_pdf(x_input_tf) x_transformed, x_transformed_log_pdf = serial_flow.transform( x_input_tf, x_log_pdf) # weights = [0.33, 0.33, 1-0.33-0.33] # mean_1 = tf.zeros(shape=(batch_size_tf, n_dim))+np.asarray([-0.5, -0.5])[np.newaxis, :] # mean_2 = tf.zeros(shape=(batch_size_tf, n_dim))+np.asarray([-0.5, +0.5])[np.newaxis, :] # mean_3 = tf.zeros(shape=(batch_size_tf, n_dim))+np.asarray([+0.5, -0.5])[np.newaxis, :] # log_var_1 = tf.log(tf.ones(shape=(batch_size_tf, n_dim))*0.3)
def inference(self, batch, additional_inputs_tf): self.epoch = additional_inputs_tf[0] self.b_identity = additional_inputs_tf[1] if len(batch['observed']['properties']['flat']) > 0: for e in batch['observed']['properties']['flat']: e['dist'] = 'dirac' else: for e in batch['observed']['properties']['image']: e['dist'] = 'dirac' self.input_sample = batch['observed']['data'] self.input_dist = distributions.ProductDistribution( sample_properties=batch['observed']['properties'], params=self.input_sample) if not self.bModules: self.generate_modules(batch) try: self.n_time = batch['observed']['properties']['flat'][0]['size'][1] except: self.n_time = batch['observed']['properties']['image'][0]['size'][ 1] try: self.batch_size_tf = tf.shape(self.input_sample['flat'])[0] except: self.batch_size_tf = tf.shape(self.input_sample['image'])[0] ############################################################################# # GENERATOR self.flow_param_list = self.FlowMap.forward(batch) self.wolf_param_list = self.WolfMap.forward(batch) n_output = np.prod( batch['observed']['properties']['image'][0]['size'][2:]) # Euclidean_flow_class = transforms.PiecewisePlanarScalingFlow # Euclidean_flow_class = transforms.RealNVPFlow Euclidean_flow_class = transforms.NonLinearIARFlow self.pre_flow_object = transforms.SerialFlow([\ Euclidean_flow_class(input_dim=self.config['n_latent'], parameters=self.wolf_param_list[0]), transforms.SpecificRotationFlow(input_dim=self.config['n_latent']), Euclidean_flow_class(input_dim=self.config['n_latent'], parameters=self.wolf_param_list[1]), transforms.SpecificRotationFlow(input_dim=self.config['n_latent']), Euclidean_flow_class(input_dim=self.config['n_latent'], parameters=self.wolf_param_list[2]), ]) self.flow_object = transforms.SerialFlow([\ Euclidean_flow_class(input_dim=self.config['n_latent'], parameters=self.flow_param_list[0]), transforms.SpecificRotationFlow(input_dim=self.config['n_latent']), Euclidean_flow_class(input_dim=self.config['n_latent'], parameters=self.flow_param_list[1]), transforms.RiemannianFlow(input_dim=self.config['n_latent'], output_dim=n_output, n_input_NOM=self.config['rnf_prop']['n_input_NOM'], n_output_NOM=self.config['rnf_prop']['n_output_NOM'], parameters=self.flow_param_list[-2]), transforms.CompoundRotationFlow(input_dim=n_output, parameters=self.flow_param_list[-1]), ]) self.prior_param = self.PriorMap.forward( (tf.zeros(shape=(self.batch_size_tf, 1)), )) self.prior_dist = distributions.DiagonalGaussianDistribution( params=self.prior_param) self.prior_latent_code = self.prior_dist.sample() self.pre_prior_latent_code, _ = self.pre_flow_object.inverse_transform( self.prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) self.transformed_prior_latent_code, _ = self.flow_object.transform( self.pre_prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) self.obs_sample_param = { 'flat': None, 'image': tf.reshape(self.transformed_prior_latent_code, [ -1, 1, *batch['observed']['properties']['image'][0]['size'][2:] ]) } self.obs_sample_dist = distributions.ProductDistribution( sample_properties=batch['observed']['properties'], params=self.obs_sample_param) self.obs_sample = self.obs_sample_dist.sample(b_mode=True) if not os.path.exists( str(Path.home()) + '/ExperimentalResults/FixedSamples/'): os.makedirs( str(Path.home()) + '/ExperimentalResults/FixedSamples/') if os.path.exists( str(Path.home()) + '/ExperimentalResults/FixedSamples/np_constant_prior_sample_' + str(self.prior_latent_code.get_shape().as_list()[-1]) + '.npz'): np_constant_prior_sample = np.load( str(Path.home()) + '/ExperimentalResults/FixedSamples/np_constant_prior_sample_' + str(self.prior_latent_code.get_shape().as_list()[-1]) + '.npz') else: np_constant_prior_sample = np.random.normal( loc=0., scale=1., size=[400, self.prior_latent_code.get_shape().as_list()[-1]]) np.save( str(Path.home()) + '/ExperimentalResults/FixedSamples/np_constant_prior_sample_' + str(self.prior_latent_code.get_shape().as_list()[-1]) + '.npz', np_constant_prior_sample) self.constant_prior_latent_code = tf.constant( np.asarray(np_constant_prior_sample), dtype=np.float32) self.constant_pre_prior_latent_code, _ = self.pre_flow_object.inverse_transform( self.constant_prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) self.constant_transformed_prior_latent_code, _ = self.flow_object.transform( self.constant_pre_prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) self.constant_obs_sample_param = { 'flat': None, 'image': tf.reshape(self.constant_transformed_prior_latent_code, [ -1, 1, *batch['observed']['properties']['image'][0]['size'][2:] ]) } self.constant_obs_sample_dist = distributions.ProductDistribution( sample_properties=batch['observed']['properties'], params=self.constant_obs_sample_param) self.constant_obs_sample = self.constant_obs_sample_dist.sample( b_mode=True) # if self.config['n_latent'] == 2: # grid_scale = 3 # x = np.linspace(-grid_scale, grid_scale, 20) # y = np.linspace(grid_scale, -grid_scale, 20) # xv, yv = np.meshgrid(x, y) # np_constant_prior_grid_sample = np.concatenate((xv.flatten()[:, np.newaxis], yv.flatten()[:, np.newaxis][:]), axis=1) # self.constant_grid_prior_latent_code = tf.constant(np.asarray(np_constant_prior_grid_sample), dtype=np.float32) # self.constant_grid_pre_prior_latent_code, _ = self.pre_flow_object.inverse_transform(self.constant_grid_prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) # self.constant_grid_transformed_prior_latent_code, _ = self.flow_object.transform(self.constant_grid_pre_prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) # self.constant_grid_obs_sample_param = {'flat': None, 'image': tf.reshape(self.constant_grid_transformed_prior_latent_code, [-1, 1, *batch['observed']['properties']['image'][0]['size'][2:]])} # self.constant_grid_obs_sample_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.constant_grid_obs_sample_param) # self.constant_grid_obs_sample = self.constant_grid_obs_sample_dist.sample(b_mode=True) ############################################################################# # ENCODER if self.config['encoder_mode'] == 'Deterministic': self.epsilon = None if self.config['encoder_mode'] == 'Gaussian' or self.config[ 'encoder_mode'] == 'GaussianLeastVariance' or self.config[ 'encoder_mode'] == 'UnivApprox' or 'UnivApproxNoSpatial' in self.config[ 'encoder_mode'] or self.config[ 'encoder_mode'] == 'UnivApproxSine': self.epsilon_param = self.EpsilonMap.forward( (tf.zeros(shape=(self.batch_size_tf, 1)), )) self.epsilon_dist = distributions.DiagonalGaussianDistribution( params=self.epsilon_param) self.epsilon = self.epsilon_dist.sample() self.pre_posterior_latent_code_expanded, self.pre_posterior_latent_code_det_expanded = self.Encoder.forward( self.input_sample, noise=self.epsilon) self.pre_posterior_latent_code = self.pre_posterior_latent_code_expanded[:, 0, :] self.posterior_latent_code, self.posterior_delta_log_pdf = self.pre_flow_object.transform( self.pre_posterior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) self.posterior_log_pdf = self.prior_dist.log_pdf( self.posterior_latent_code) self.pre_posterior_log_pdf = self.posterior_log_pdf - self.posterior_delta_log_pdf # self.pre_posterior_latent_code, self.pre_posterior_log_pdf = self.pre_flow_object.inverse_transform(self.posterior_latent_code, self.posterior_log_pdf) self.transformed_pre_posterior_latent_code, self.transformed_pre_posterior_log_pdf = self.flow_object.transform( self.pre_posterior_latent_code, self.pre_posterior_log_pdf) self.reconst_param = { 'flat': None, 'image': tf.reshape(self.transformed_pre_posterior_latent_code, [ -1, 1, *batch['observed']['properties']['image'][0]['size'][2:] ]) } self.reconst_dist = distributions.ProductDistribution( sample_properties=batch['observed']['properties'], params=self.reconst_param) self.reconst_sample = self.reconst_dist.sample(b_mode=True) self.interpolated_posterior_latent_code = helper.interpolate_latent_codes( self.posterior_latent_code, size=self.batch_size_tf // 2) # self.interpolated_pre_posterior_latent_code, _ = self.pre_flow_object.inverse_transform(tf.reshape(self.interpolated_posterior_latent_code, [-1, self.interpolated_posterior_latent_code.get_shape().as_list()[-1]]), tf.zeros(shape=(self.batch_size_tf, 1))) # self.interpolated_transformed_posterior_latent_code, _ = self.flow_object.transform(self.interpolated_pre_posterior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) # self.interpolated_obs = {'flat': None, 'image': tf.reshape(self.interpolated_transformed_posterior_latent_code, [-1, 10, *batch['observed']['properties']['image'][0]['size'][2:]])} self.interpolated_obs = { 'flat': None, 'image': tf.tile( self.input_sample['image'][:self.batch_size_tf // 2, :, :, :, :], [1, 10, 1, 1, 1]) } self.enc_reg_cost = -tf.reduce_mean( self.transformed_pre_posterior_log_pdf) self.cri_reg_cost = -tf.reduce_mean(self.pre_posterior_log_pdf) ############################################################################# # REGULARIZER self.reg_target_dist = self.reconst_dist self.reg_target_sample = self.reconst_sample self.reg_dist = self.reconst_dist self.reg_sample = self.reconst_sample ############################################################################# # OBJECTIVES self.OT_primal = self.sample_distance_function(self.input_sample, self.reconst_sample) self.mean_OT_primal = tf.reduce_mean(self.OT_primal) if '0' in self.config['timers']: lambda_t = helper.hardstep( (self.epoch - float(self.config['timers']['0']['start'])) / float(self.config['timers']['0']['timescale']) + 1e-5) overall_cost = self.mean_OT_primal + lambda_t * self.config[ 'enc_reg_strength'] * self.enc_reg_cost else: overall_cost = self.mean_OT_primal + self.config[ 'enc_reg_strength'] * self.enc_reg_cost # self.cri_cost = self.cri_reg_cost # self.cri_cost = self.config['enc_reg_strength']*self.enc_reg_cost self.cri_cost = self.enc_reg_cost self.enc_cost = overall_cost self.gen_cost = overall_cost
if flow_class_2.required_num_parameters(n_dim) > 0: with tf.variable_scope("eft_second"+str(i), reuse=False): flow_class_2_parameters = 1*tf.layers.dense(inputs = flow_param_input, units = flow_class_2.required_num_parameters(n_dim), use_bias = False, activation = None) if flow_class_2_parameters.get_shape()[0].value is not None and flow_class_2_parameters.get_shape()[0].value == 1: batch_tile_2 = im_target_np.shape[0] else: batch_tile_2 = 1 flow_class_2_parameters_tiled = tf.reshape(tf.tile(flow_class_2_parameters[:,np.newaxis,:], [batch_tile_2, im_target_np.shape[1]*im_target_np.shape[2], 1]), [-1, flow_class_2_parameters.get_shape()[-1].value]) flow_class_2_parameters_sampled_tiled = tf.reshape(tf.tile(flow_class_2_parameters[:,np.newaxis,:], [batch_tile_2, n_location_samples, 1]), [-1, flow_class_2_parameters.get_shape()[-1].value]) flow_class_2_parameters_location_tiled = tf.reshape(tf.tile(flow_class_2_parameters[:,np.newaxis,:], [batch_tile_2, loc_batch_size, 1]), [-1, flow_class_2_parameters.get_shape()[-1].value]) normalizing_flow_list.append(flow_class_2(input_dim=n_dim, parameters=flow_class_2_parameters_tiled)) normalizing_flow_sampled_list.append(flow_class_2(input_dim=n_dim, parameters=flow_class_2_parameters_sampled_tiled)) normalizing_flow_location_list.append(flow_class_2(input_dim=n_dim, parameters=flow_class_2_parameters_location_tiled)) serial_flow = transforms.SerialFlow(normalizing_flow_list) serial_flow_sampled = transforms.SerialFlow(normalizing_flow_sampled_list) serial_flow_location = transforms.SerialFlow(normalizing_flow_location_list) location_input_tiled = tf.reshape(tf.tile(location_input_tf[np.newaxis, :, :], [batch_tile_2, 1, 1]), [-1, location_input_tf.get_shape()[-1].value]) location_transformed_raw, _ = serial_flow_location.inverse_transform(location_input_tiled, None) location_transformed_tf = tf.reshape(location_transformed_raw, [batch_tile_2, loc_batch_size, location_input_tf.get_shape()[-1].value]) def clousure_of_closure(serial_flow): def nonlinear_pixel_transformation_clousure(batch_input_pixels): # input = [tf.shape(input_pixels)[0] (corresponding the individual pixels in a grid of output image), 2] # output = [batch_size_tf, 2, tf.shape(input_pixels)[0]] # serial_flow does not allow different transformations for each image in the batch # See the note in linear_pixel_transformation_clousure for understanding the transformation. input_pixels_flat = tf.reshape(batch_input_pixels, [-1, batch_input_pixels.get_shape()[-1].value]) output_pixels_flat, _ = serial_flow.transform(input_pixels_flat, None)
def inference(self, batch, additional_inputs_tf): self.epoch = additional_inputs_tf[0] self.b_identity = additional_inputs_tf[1] if len(batch['observed']['properties']['flat'])>0: for e in batch['observed']['properties']['flat']: e['dist']='dirac' else: for e in batch['observed']['properties']['image']: e['dist']='dirac' self.input_sample = batch['observed']['data'] self.input_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.input_sample) if not self.bModules: self.generate_modules(batch) try: self.n_time = batch['observed']['properties']['flat'][0]['size'][1] except: self.n_time = batch['observed']['properties']['image'][0]['size'][1] try: self.batch_size_tf = tf.shape(self.input_sample['flat'])[0] except: self.batch_size_tf = tf.shape(self.input_sample['image'])[0] ############################################################################# # GENERATOR self.pre_prior_param = self.PriorMap.forward((tf.zeros(shape=(self.batch_size_tf, 1)),)) # self.pre_prior_dist = distributions.UniformDistribution(params = self.pre_prior_param) self.pre_prior_dist = distributions.DiagonalBetaDistribution(params = self.pre_prior_param) self.pre_prior_latent_code = self.pre_prior_dist.sample() self.pre_prior_latent_code_log_pdf = self.pre_prior_dist.log_pdf(self.pre_prior_latent_code) self.ambient_prior_param = self.PriorMapBetaInverted.forward((tf.zeros(shape=(self.batch_size_tf, 1)),)) self.ambient_prior_dist = distributions.DiagonalBetaDistribution(params = self.ambient_prior_param) self.flow_param_list = self.FlowMap.forward() # self.flow_object = transforms.SerialFlow([ \ # transforms.InverseOpenIntervalDimensionFlow(input_dim=self.config['n_latent']), # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[0]), # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[1]), # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[2]), # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[3]), # # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[4]), # # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[5]), # # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # # transforms.NonLinearIARFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[6]), # transforms.OpenIntervalDimensionFlow(input_dim=self.config['n_latent']), # ]) # self.flow_object = transforms.SerialFlow([ \ # transforms.InverseOpenIntervalDimensionFlow(input_dim=self.config['n_latent']), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[0]), # transforms.HouseholdRotationFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[7]), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[1]), # transforms.HouseholdRotationFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[8]), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[2]), # transforms.HouseholdRotationFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[9]), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[3]), # transforms.HouseholdRotationFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[10]), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[4]), # transforms.HouseholdRotationFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[11]), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[5]), # transforms.HouseholdRotationFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[12]), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[6]), # transforms.OpenIntervalDimensionFlow(input_dim=self.config['n_latent']), # ]) self.flow_object = transforms.SerialFlow([ \ transforms.InverseOpenIntervalDimensionFlow(input_dim=self.config['n_latent']), transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[0]), transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[1]), transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[2]), transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[3]), # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[4]), # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[5]), # transforms.SpecificOrderDimensionFlow(input_dim=self.config['n_latent']), # transforms.RealNVPFlow(input_dim=self.config['n_latent'], parameters=self.flow_param_list[6]), transforms.OpenIntervalDimensionFlow(input_dim=self.config['n_latent']), ]) self.gen_flow_object = self.flow_object self.prior_latent_code, self.prior_latent_code_log_pdf = self.flow_object.inverse_transform(self.pre_prior_latent_code, self.pre_prior_latent_code_log_pdf) self.obs_sample_param = self.Generator.forward(self.prior_latent_code[:, np.newaxis, :]) self.obs_sample_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.obs_sample_param) self.obs_sample = self.obs_sample_dist.sample(b_mode=True) if not os.path.exists(str(Path.home())+'/ExperimentalResults/FixedSamples/'): os.makedirs(str(Path.home())+'/ExperimentalResults/FixedSamples/') # if os.path.exists(str(Path.home())+'/ExperimentalResults/FixedSamples/np_constant_uniform11_prior_sample_'+str(self.pre_prior_latent_code.get_shape().as_list()[-1])+'.npz'): if os.path.exists(str(Path.home())+'/ExperimentalResults/FixedSamples/np_constant_uniform01_prior_sample_'+str(self.pre_prior_latent_code.get_shape().as_list()[-1])+'.npz'): # np_constant_prior_sample = np.load(str(Path.home())+'/ExperimentalResults/FixedSamples/np_constant_uniform11_prior_sample_'+str(self.pre_prior_latent_code.get_shape().as_list()[-1])+'.npz') np_constant_prior_sample = np.load(str(Path.home())+'/ExperimentalResults/FixedSamples/np_constant_uniform01_prior_sample_'+str(self.pre_prior_latent_code.get_shape().as_list()[-1])+'.npz') else: # np_constant_prior_sample = np.random.uniform(low=-1., high=1., size=[400, self.pre_prior_latent_code.get_shape().as_list()[-1]]) np_constant_prior_sample = np.random.uniform(low=0., high=1., size=[400, self.pre_prior_latent_code.get_shape().as_list()[-1]]) # np.save(str(Path.home())+'/ExperimentalResults/FixedSamples/np_constant_uniform11_prior_sample_'+str(self.pre_prior_latent_code.get_shape().as_list()[-1])+'.npz', np_constant_prior_sample) np.save(str(Path.home())+'/ExperimentalResults/FixedSamples/np_constant_uniform01_prior_sample_'+str(self.pre_prior_latent_code.get_shape().as_list()[-1])+'.npz', np_constant_prior_sample) self.constant_pre_prior_latent_code = tf.constant(np.asarray(np_constant_prior_sample), dtype=np.float32) self.constant_prior_latent_code, _ = self.flow_object.inverse_transform(self.constant_pre_prior_latent_code, tf.zeros(shape=(self.batch_size_tf, 1))) self.constant_obs_sample_param = self.Generator.forward(self.constant_prior_latent_code[:, np.newaxis, :]) self.constant_obs_sample_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.constant_obs_sample_param) self.constant_obs_sample = self.constant_obs_sample_dist.sample(b_mode=True) if self.config['n_latent'] == 2: # x = np.linspace(-1, 1, 20) # y = np.linspace(1, -1, 20) x = np.linspace(0, 1, 20) y = np.linspace(1, 0, 20) xv, yv = np.meshgrid(x, y) np_constant_prior_grid_sample = np.concatenate((xv.flatten()[:, np.newaxis], yv.flatten()[:, np.newaxis][:]), axis=1) self.constant_prior_grid_latent_code = tf.constant(np.asarray(np_constant_prior_grid_sample), dtype=np.float32) self.constant_obs_grid_sample_param = self.Generator.forward(self.constant_prior_grid_latent_code[:, np.newaxis, :]) self.constant_obs_grid_sample_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.constant_obs_grid_sample_param) self.constant_obs_grid_sample = self.constant_obs_grid_sample_dist.sample(b_mode=True) ############################################################################# # ENCODER self.epsilon_param = self.PriorMap.forward((tf.zeros(shape=(self.batch_size_tf, 1)),)) self.epsilon_dist = distributions.DiagonalGaussianDistribution(params=self.epsilon_param) if self.config['encoder_mode'] == 'Deterministic': self.epsilon = None if self.config['encoder_mode'] == 'Gaussian' or self.config['encoder_mode'] == 'UnivApprox' or self.config['encoder_mode'] == 'UnivApproxNoSpatial' or self.config['encoder_mode'] == 'UnivApproxSine': self.epsilon = self.epsilon_dist.sample() # self.pre_posterior_latent_code = 0.95*tf.nn.tanh(self.Encoder.forward(self.input_sample, noise=self.epsilon))[:,0,:] # self.pre_posterior_latent_code = 0.9*tf.nn.sigmoid(self.Encoder.forward(self.input_sample, noise=self.epsilon))[:,0,:]+0.05 self.pre_posterior_latent_code = 0.8*tf.nn.sigmoid(self.Encoder.forward(self.input_sample, noise=self.epsilon))[:,0,:]+0.1 self.nball_param = tf.concat([self.pre_posterior_latent_code, 0.05*tf.ones(shape=(self.batch_size_tf, 1))], axis=1) self.nball_dist = distributions.UniformBallDistribution(params=self.nball_param) self.posterior_latent_code = self.nball_dist.sample() self.posterior_latent_code_log_pdf = -np.log(50000)+self.nball_dist.log_pdf(self.posterior_latent_code) self.transformed_posterior_latent_code, self.transformed_posterior_latent_code_log_pdf = self.flow_object.transform(self.posterior_latent_code, self.posterior_latent_code_log_pdf) self.hollow_nball_param = tf.concat([self.pre_posterior_latent_code, 0.05*tf.ones(shape=(self.batch_size_tf, 1)), 0.1*tf.ones(shape=(self.batch_size_tf, 1))], axis=1) self.hollow_nball_dist = distributions.UniformHollowBallDistribution(params=self.hollow_nball_param) self.hollow_posterior_latent_code = self.hollow_nball_dist.sample() self.hollow_posterior_latent_code_log_pdf = -np.log(50000)+self.hollow_nball_dist.log_pdf(self.hollow_posterior_latent_code) self.transformed_hollow_posterior_latent_code, self.transformed_hollow_posterior_latent_code_log_pdf = self.flow_object.transform(self.hollow_posterior_latent_code, self.hollow_posterior_latent_code_log_pdf) self.ambient_param = self.AmbientMap.forward((tf.zeros(shape=(self.batch_size_tf, 1)),)) self.ambient_dist = distributions.UniformDistribution(params = self.ambient_param) self.ambient_latent_code = self.ambient_dist.sample() self.ambient_latent_code_log_pdf = self.ambient_dist.log_pdf(self.ambient_latent_code) self.transformed_ambient_latent_code, self.transformed_ambient_latent_code_log_pdf = self.flow_object.transform(self.ambient_latent_code, self.ambient_latent_code_log_pdf) self.KL_transformed_prior_per = self.transformed_posterior_latent_code_log_pdf-self.pre_prior_dist.log_pdf(self.transformed_posterior_latent_code) self.KL_transformed_hollow_prior_per = self.transformed_hollow_posterior_latent_code_log_pdf-self.ambient_prior_dist.log_pdf(self.transformed_hollow_posterior_latent_code) self.KL_transformed_ambient_prior_per = self.transformed_ambient_latent_code_log_pdf-self.ambient_prior_dist.log_pdf(self.transformed_ambient_latent_code) self.KL_transformed_prior = tf.reduce_mean(self.KL_transformed_prior_per) self.KL_transformed_hollow_prior = tf.reduce_mean(self.KL_transformed_hollow_prior_per) self.KL_transformed_ambient_prior = tf.reduce_mean(self.KL_transformed_ambient_prior_per) self.interpolated_posterior_latent_code = helper.interpolate_latent_codes(self.posterior_latent_code, size=self.batch_size_tf//2) self.interpolated_obs = self.Generator.forward(self.interpolated_posterior_latent_code) self.reconst_param = self.Generator.forward(self.posterior_latent_code[:, np.newaxis, :]) self.reconst_dist = distributions.ProductDistribution(sample_properties = batch['observed']['properties'], params = self.reconst_param) self.reconst_sample = self.reconst_dist.sample(b_mode=True) ### Primal Penalty ############################################################################# # REGULARIZER self.reg_target_dist = self.reconst_dist self.reg_target_sample = self.reconst_sample self.reg_dist = self.reconst_dist self.reg_sample = self.reconst_sample ############################################################################# # OBJECTIVES # Divergence # if self.config['divergence_mode'] == 'GAN' or self.config['divergence_mode'] == 'NS-GAN': # self.div_cost = -(tf.reduce_mean(tf.log(tf.nn.sigmoid(self.div_posterior)+10e-7))+tf.reduce_mean(tf.log(1-tf.nn.sigmoid(self.div_prior)+10e-7))) # if self.config['divergence_mode'] == 'WGAN-GP': # uniform_dist = distributions.UniformDistribution(params = tf.concat([tf.zeros(shape=(self.batch_size_tf, 1)), tf.ones(shape=(self.batch_size_tf, 1))], axis=1)) # uniform_w = uniform_dist.sample() # self.trivial_line = uniform_w[:,np.newaxis,:]*self.pre_posterior_latent_code_expanded+(1-uniform_w[:,np.newaxis,:])*self.prior_latent_code_expanded # self.div_trivial_line = self.Diverger.forward(self.trivial_line) # self.trivial_line_grad = tf.gradients(tf.reduce_sum(self.div_trivial_line), [self.trivial_line])[0] # self.trivial_line_grad_norm = helper.safe_tf_sqrt(tf.reduce_sum(self.trivial_line_grad**2, axis=-1, keep_dims=False)[:,:,np.newaxis]) # self.trivial_line_grad_norm_1_penalties = ((self.trivial_line_grad_norm-1)**2) # self.div_reg_cost = tf.reduce_mean(self.trivial_line_grad_norm_1_penalties) # # self.div_cost = -(tf.reduce_mean(self.div_posterior)-tf.reduce_mean(self.div_prior))+10*self.div_reg_cost # self.div_cost = (self.KL_transformed_prior+self.KL_transformed_ambient_prior+self.KL_transformed_hollow_prior) self.div_cost = (self.KL_transformed_prior+self.KL_transformed_hollow_prior) # ### Encoder # b_use_timer, timescale, starttime = False, 10, 5 self.OT_primal = self.sample_distance_function(self.input_sample, self.reconst_sample) self.mean_OT_primal = tf.reduce_mean(self.OT_primal) # if b_use_timer: # self.mean_POT_primal = self.mean_OT_primal+helper.hardstep((self.epoch-float(starttime))/float(timescale))*self.config['enc_reg_strength']*self.enc_reg_cost # else: # self.mean_POT_primal = self.mean_OT_primal+self.config['enc_reg_strength']*self.enc_reg_cost # self.enc_cost = self.mean_POT_primal self.enc_cost = self.mean_OT_primal # ### Critic # # self.cri_cost = helper.compute_MMD(self.pre_prior_latent_code, self.prior_latent_code) # if self.config['divergence_mode'] == 'NS-GAN': # self.cri_cost = -tf.reduce_mean(tf.log(tf.nn.sigmoid(self.div_prior)+10e-7))+self.config['enc_reg_strength']*helper.compute_MMD(self.pre_prior_latent_code, self.prior_latent_code) # elif self.config['divergence_mode'] == 'GAN': # self.cri_cost = tf.reduce_mean(tf.log(1-tf.nn.sigmoid(self.div_prior)+10e-7))+self.config['enc_reg_strength']*helper.compute_MMD(self.pre_prior_latent_code, self.prior_latent_code) # elif self.config['divergence_mode'] == 'WGAN-GP': # self.cri_cost = -tf.reduce_mean(self.div_prior)+self.config['enc_reg_strength']*helper.compute_MMD(self.pre_prior_latent_code, self.prior_latent_code) ### Generator self.gen_cost = self.mean_OT_primal
################################# TF training ################################################################## if use_gpu: os.environ['CUDA_VISIBLE_DEVICES'] = '0' print("os.environ['CUDA_VISIBLE_DEVICES'], ", os.environ['CUDA_VISIBLE_DEVICES']) x_input = tf.placeholder(tf.float32, [None, n_out]) batch_size_tf = tf.shape(x_input)[0] n_RF_parameter = transforms.RiemannianFlow.required_num_parameters(n_latent, n_out, n_input_CPO, n_output_CPO) n_HF_parameter = transforms.HouseholdRotationFlow.required_num_parameters(n_out) riemannian_flow_parameters = 1*tf.layers.dense(inputs = tf.ones(shape=(1, 1)), units = n_RF_parameter, use_bias = False, activation = None) householder_flow_parameters = 1*tf.layers.dense(inputs = tf.ones(shape=(1, 1)), units = n_HF_parameter, use_bias = False, activation = None) riemannian_flow = transforms.RiemannianFlow(input_dim=n_latent, output_dim=n_out, n_input_CPO=n_input_CPO, n_output_CPO=n_output_CPO, parameters=riemannian_flow_parameters) householder_flow = transforms.HouseholdRotationFlow(input_dim=n_out, parameters=householder_flow_parameters) serial_flow = transforms.SerialFlow([riemannian_flow, householder_flow]) prior_param = tf.zeros((batch_size_tf, 2*n_latent), tf.float32) prior_dist = distributions.DiagonalGaussianDistribution(params=prior_param) lay_1 = tf.layers.dense(inputs = x_input, units = 200, use_bias = True, activation = tf.nn.relu) lay_2 = lay_1+tf.layers.dense(inputs = lay_1, units = 200, use_bias = True, activation = tf.nn.relu) lay_3 = lay_2+tf.layers.dense(inputs = lay_2, units = 200, use_bias = True, activation = tf.nn.relu) lay_4 = lay_3+tf.layers.dense(inputs = lay_3, units = 200, use_bias = True, activation = tf.nn.relu) z_x = tf.layers.dense(inputs = lay_4, units = n_latent, use_bias = True, activation = None) log_pdf_z_x = prior_dist.log_pdf(z_x) x_rec, log_pdf_x_rec = serial_flow.transform(z_x, log_pdf_z_x) rec_cost = 100*tf.reduce_mean(tf.reduce_sum((x_rec-x_input)**2, axis=1)) # rec_cost = tf.reduce_mean(tf.reduce_sum((x_rec-x_input)**2, axis=1)) optimizer = tf.train.AdamOptimizer(learning_rate=0.001, beta1=0.1, beta2=0.1, epsilon=1e-08)