] + n_points) for i in range(len(n_points)): samples_list.append( np.squeeze(X)[:25, n_points_c[i]:n_points_c[i + 1]]) plot_samples(None, samples_list, scatter=False, alpha=.7, c='k', fname='%s/samples' % args.data) print('Plotting synthesized x0 ...') plot_grid(5, gen_func=model.synthesize_x0, d=latent_dim[0], scale=.95, scatter=False, alpha=.7, c='k', fname='{}/x0'.format(results_dir)) print('Plotting synthesized x1 ...') plot_grid(5, gen_func=model.synthesize_x1, d=latent_dim[1], scale=.95, scatter=False, alpha=.7, c='k', fname='{}/x1'.format(results_dir)) print('Plotting synthesized assemblies ...')
def train(self, X_train, train_steps=2000, batch_size=256, save_interval=0, save_dir=None): assert X_train.shape[1] == self.conc_points X_train = preprocess(X_train) self.X0_train = X_train[:, :self.n_points[0]] self.X1_train = X_train[:, self.n_points[0]:self.n_points[0]+self.n_points[1]] self.X2_train = X_train[:, self.n_points[0]+self.n_points[1]:-self.n_points[3]] self.X3_train = X_train[:, -self.n_points[3]:] # Inputs self.x0 = tf.placeholder(tf.float32, shape=[None, self.n_points[0], 2, 1], name='x0') self.c0 = tf.placeholder(tf.float32, shape=[None, self.latent_dim[0]], name='c0') self.z0 = tf.placeholder(tf.float32, shape=[None, self.noise_dim[0]], name='z0') self.x1 = tf.placeholder(tf.float32, shape=[None, self.n_points[1], 2, 1], name='x1') self.c1 = tf.placeholder(tf.float32, shape=[None, self.latent_dim[1]], name='c1') self.z1 = tf.placeholder(tf.float32, shape=[None, self.noise_dim[1]], name='z1') self.x2 = tf.placeholder(tf.float32, shape=[None, self.n_points[2], 2, 1], name='x2') self.c2 = tf.placeholder(tf.float32, shape=[None, self.latent_dim[2]], name='c2') self.z2 = tf.placeholder(tf.float32, shape=[None, self.noise_dim[2]], name='z2') self.x3 = tf.placeholder(tf.float32, shape=[None, self.n_points[3], 2, 1], name='x3') self.c3 = tf.placeholder(tf.float32, shape=[None, self.latent_dim[3]], name='c3') self.z3 = tf.placeholder(tf.float32, shape=[None, self.noise_dim[3]], name='z3') # Targets c0_target = tf.placeholder(tf.float32, shape=[None, self.latent_dim[0]]) c1_target = tf.placeholder(tf.float32, shape=[None, self.latent_dim[1]]) c2_target = tf.placeholder(tf.float32, shape=[None, self.latent_dim[2]]) c3_target = tf.placeholder(tf.float32, shape=[None, self.latent_dim[3]]) # Outputs d_real, _, _, _, _ = self.discriminator(self.x0, self.x1, self.x2, self.x3) self.x0_fake, cp_train, w_train = self.parent_generator(self.c0, self.z0, 'G0', self.n_points[0], self.bezier_degree[0]) f0 = self.encoder(self.x0_fake, 'E0', training=False) self.x1_fake = self.child_generator(self.c1, self.z1, f0, 'G1', self.n_points[1]) f1 = self.encoder(self.x1_fake, 'E1', training=False) self.x2_fake = self.child_generator(self.c2, self.z2, f1, 'G2', self.n_points[2]) f2 = self.encoder(self.x2_fake, 'E2', training=False) self.x3_fake = self.child_generator(self.c3, self.z3, f2, 'G3', self.n_points[3]) d_fake, self.c0_fake_train, self.c1_fake_train, self.c2_fake_train, self.c3_fake_train = self.discriminator(self.x0_fake, self.x1_fake, self.x2_fake, self.x3_fake) self.d_test, self.c0_test, self.c1_test, self.c2_test, self.c3_test = self.discriminator(self.x0, self.x1, self.x2, self.x3, training=False) # Losses # Cross entropy losses for D d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_real, labels=tf.ones_like(d_real))) d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake, labels=tf.zeros_like(d_fake))) # Cross entropy losses for G g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake, labels=tf.ones_like(d_fake))) # Regularization for w, cp, a, and b (parent) r_w_loss = tf.reduce_mean(w_train[:,1:-1], axis=[1,2]) cp_dist = tf.norm(cp_train[:,1:]-cp_train[:,:-1], axis=-1) r_cp_loss = tf.reduce_mean(cp_dist, axis=-1) r_cp_loss1 = tf.reduce_max(cp_dist, axis=-1) ends = cp_train[:,0] - cp_train[:,-1] r_ends_loss = tf.norm(ends, axis=-1) r_loss = r_w_loss + r_cp_loss + 0*r_cp_loss1 + r_ends_loss r_loss = tf.reduce_mean(r_loss) # Gaussian loss for Q def gaussian_loss(c, c_target): c_mean = c[:, 0, :] c_logstd = c[:, 1, :] epsilon = (c_target - c_mean) / (tf.exp(c_logstd) + EPSILON) q_loss = (c_logstd + 0.5 * tf.square(epsilon)) q_loss = tf.reduce_mean(q_loss) return q_loss q_loss = gaussian_loss(self.c0_fake_train, c0_target) + \ gaussian_loss(self.c1_fake_train, c1_target) + \ gaussian_loss(self.c2_fake_train, c2_target) + \ gaussian_loss(self.c3_fake_train, c3_target) # Optimizers d_optimizer = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.5) g_optimizer = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.5) # Generator variables g0_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='G0') g1_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='G1') g2_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='G2') g3_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='G3') # Discriminator variables dis_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='D') # Training operations d_train_real = d_optimizer.minimize(d_loss_real, var_list=dis_vars) d_train_fake = d_optimizer.minimize(d_loss_fake + 0.1*q_loss, var_list=dis_vars) g_train = g_optimizer.minimize(g_loss + r_loss + 0.1*q_loss, var_list=[g0_vars, g1_vars, g2_vars, g3_vars]) # Initialize the variables (i.e. assign their default value) init = tf.global_variables_initializer() # Create summaries to monitor losses tf.summary.scalar('D_loss_for_real', d_loss_real) tf.summary.scalar('D_loss_for_fake', d_loss_fake) tf.summary.scalar('G_loss', g_loss) tf.summary.scalar('R_loss', r_loss) tf.summary.scalar('Q_loss', q_loss) # Merge all summaries into a single op merged_summary_op = tf.summary.merge_all() # Add ops to save and restore all the variables. saver = tf.train.Saver() # Start training self.sess = tf.Session() # Run the initializer self.sess.run(init) # op to write logs to Tensorboard summary_writer = tf.summary.FileWriter('{}/logs'.format(save_dir), graph=self.sess.graph) for t in range(train_steps): # Disriminator update ind = np.random.choice(self.X0_train.shape[0], size=batch_size, replace=False) X0_real = self.X0_train[ind] X1_real = self.X1_train[ind] X2_real = self.X2_train[ind] X3_real = self.X3_train[ind] _, dlr = self.sess.run([d_train_real, d_loss_real], feed_dict={self.x0: X0_real, self.x1: X1_real, self.x2: X2_real, self.x3: X3_real}) X0_latent = np.random.uniform(size=(batch_size, self.latent_dim[0])) X0_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[0])) X0_fake = self.sess.run(self.x0_fake, feed_dict={self.c0: X0_latent, self.z0: X0_noise}) X1_latent = np.random.uniform(size=(batch_size, self.latent_dim[1])) X1_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[1])) X1_fake = self.sess.run(self.x1_fake, feed_dict={self.c1: X1_latent, self.z1: X1_noise, self.x0_fake: X0_fake}) X2_latent = np.random.uniform(size=(batch_size, self.latent_dim[2])) X2_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[2])) X2_fake = self.sess.run(self.x2_fake, feed_dict={self.c2: X2_latent, self.z2: X2_noise, self.x1_fake: X1_fake}) X3_latent = np.random.uniform(size=(batch_size, self.latent_dim[3])) X3_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[3])) X3_fake = self.sess.run(self.x3_fake, feed_dict={self.c3: X3_latent, self.z3: X3_noise, self.x2_fake: X2_fake}) assert not (np.any(np.isnan(X0_fake)) or np.any(np.isnan(X1_fake)) or np.any(np.isnan(X2_fake)) or np.any(np.isnan(X3_fake))) _, dlf, qld = self.sess.run([d_train_fake, d_loss_fake, q_loss], feed_dict={self.x0_fake: X0_fake, self.x1_fake: X1_fake, self.x2_fake: X2_fake, self.x3_fake: X3_fake, c0_target: X0_latent, c1_target: X1_latent, c2_target: X2_latent, c3_target: X3_latent}) # Generator update X0_latent = np.random.uniform(size=(batch_size, self.latent_dim[0])) X0_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[0])) X0_fake = self.sess.run(self.x0_fake, feed_dict={self.c0: X0_latent, self.z0: X0_noise}) X1_latent = np.random.uniform(size=(batch_size, self.latent_dim[1])) X1_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[1])) X1_fake = self.sess.run(self.x1_fake, feed_dict={self.c1: X1_latent, self.z1: X1_noise, self.x0_fake: X0_fake}) X2_latent = np.random.uniform(size=(batch_size, self.latent_dim[2])) X2_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[2])) X2_fake = self.sess.run(self.x2_fake, feed_dict={self.c2: X2_latent, self.z2: X2_noise, self.x1_fake: X1_fake}) X3_latent = np.random.uniform(size=(batch_size, self.latent_dim[3])) X3_noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim[3])) X3_fake = self.sess.run(self.x2_fake, feed_dict={self.c3: X3_latent, self.z3: X3_noise, self.x2_fake: X2_fake}) _, gl, rl, qlg = self.sess.run([g_train, g_loss, r_loss, q_loss], feed_dict={self.c0: X0_latent, self.z0: X0_noise, self.c1: X1_latent, self.z1: X1_noise, self.c2: X2_latent, self.z2: X2_noise, self.c3: X3_latent, self.z3: X3_noise, c0_target: X0_latent, c1_target: X1_latent, c2_target: X2_latent, c3_target: X3_latent}) summary_str = self.sess.run(merged_summary_op, feed_dict={self.x0: X0_real, self.x1: X1_real, self.x2: X2_real, self.x3: X3_real, self.x0_fake: X0_fake, self.x1_fake: X1_fake, self.x2_fake: X2_fake, self.x3_fake: X3_fake, self.c0: X0_latent, self.z0: X0_noise, c0_target: X0_latent, self.c1: X1_latent, self.z1: X1_noise, c1_target: X1_latent, self.c2: X2_latent, self.z2: X2_noise, c2_target: X2_latent, self.c3: X3_latent, self.z3: X3_noise, c3_target: X3_latent}) summary_writer.add_summary(summary_str, t+1) # Show messages log_mesg = "%d: [D] real %f fake %f q %f" % (t+1, dlr, dlf, qld) log_mesg = "%s [G] %f reg %f q %f" % (log_mesg, gl, rl, qlg) print(log_mesg) if save_interval>0 and (t+1)%save_interval==0: # Save the variables to disk. save_path = saver.save(self.sess, '{}/model'.format(save_dir)) print('Model saved in path: %s' % save_path) print('Plotting results ...') plot_grid(5, gen_func=self.synthesize_x0, d=self.latent_dim[0], scale=.95, scatter=True, alpha=.7, fname='{}/x0'.format(save_dir)) plot_grid(5, gen_func=self.synthesize_x1, d=self.latent_dim[1], scale=.95, scatter=True, alpha=.7, fname='{}/x1'.format(save_dir)) plot_grid(5, gen_func=self.synthesize_x2, d=self.latent_dim[2], scale=.95, scatter=True, alpha=.7, fname='{}/x2'.format(save_dir)) plot_grid(5, gen_func=self.synthesize_x3, proba_func=self.pred_proba, d=self.latent_dim[3], scale=.95, scatter=True, alpha=.7, fname='{}/x3'.format(save_dir))
def train(self, train_steps=2000, batch_size=256, save_interval=0, mode='startover'): g1_fname = '../hgan_idetc2018_data/airfoil/wo_info/generator1.h5' g2_fname = '../hgan_idetc2018_data/airfoil/wo_info/generator2.h5' d_fname = '../hgan_idetc2018_data/airfoil/wo_info/discriminator.h5' if os.path.isfile(g1_fname) and os.path.isfile( g2_fname) and os.path.isfile(d_fname): trained_existed = True else: trained_existed = False if mode != 'startover' and trained_existed: self.dis = self.D = load_model(d_fname) self.gen1 = self.G1 = load_model(g1_fname) self.gen2 = self.G2 = load_model(g2_fname) else: self.dis = self.discriminator() self.gen1 = self.generator1() self.gen2 = self.generator2() self.dis_model = self.discriminator_model() self.adv_model1 = self.adversarial_model1() self.adv_model2 = self.adversarial_model2() if mode != 'evaluate' or not trained_existed: for t in range(train_steps): sigma = np.exp(-t / 1e4) # annealed noise scale # Train discriminator model and adversarial model ind = np.random.choice(self.x_train.shape[0], size=batch_size, replace=False) X_train = self.x_train[ind] X_train += np.random.normal(scale=sigma, size=X_train.shape) y_real = np.zeros((batch_size, 2), dtype=np.uint8) y_real[:, 1] = 1 # y_real = label_flipping(y_real, .1) y_latent1 = np.random.uniform(size=(batch_size, self.latent_dim)) y_latent2 = np.random.uniform(size=(batch_size, self.latent_dim)) d_loss_real = self.dis_model.train_on_batch(X_train, y_real) noise1 = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim)) noise2 = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim)) y_latent1 = np.random.uniform(size=(batch_size, self.latent_dim)) y_latent2 = np.random.uniform(size=(batch_size, self.latent_dim)) X1_fake = self.gen1.predict_on_batch([y_latent1, noise1]) X2_fake = self.gen2.predict_on_batch( [y_latent2, noise2, X1_fake]) X_fake = np.concatenate((X1_fake, X2_fake), axis=1) X_fake += np.random.normal(scale=sigma, size=X_fake.shape) y_fake = np.zeros((batch_size, 2), dtype=np.uint8) y_fake[:, 0] = 1 # y_fake = label_flipping(y_fake, .1) d_loss_fake = self.dis_model.train_on_batch(X_fake, y_fake) a1_loss = self.adv_model1.train_on_batch( [y_latent1, noise1, y_latent2, noise2], y_real) a2_loss = self.adv_model2.train_on_batch( [y_latent2, noise2, X1_fake], y_real) log_mesg = "%d: [D] real %f fake %f" % (t + 1, d_loss_real, d_loss_fake) log_mesg = "%s [A1] fake %f" % (log_mesg, a1_loss) log_mesg = "%s [A2] fake %f" % (log_mesg, a2_loss) print(log_mesg) if save_interval > 0 and (t + 1) % save_interval == 0: self.gen1.save(g1_fname) self.gen2.save(g2_fname) self.dis.save(d_fname) print 'Plotting results ...' from shape_plot import plot_grid plot_grid(9, gen_func=self.synthesize_parent, d=self.latent_dim, scale=.95, save_path='airfoil/wo_info/parent.svg') plot_grid(9, gen_func=self.synthesize_child, d=self.latent_dim, scale=.95, save_path='airfoil/wo_info/child.svg')
c='k', fname='{}/assemblies'.format(results_dir)) print('Plotting synthesized assemblies in order ...') def synthesize(X_latent, dims=[0, 1]): X_latent_full = np.zeros((X_latent.shape[0], latent_dim)) X_latent_full[:, dims] = X_latent return model.synthesize(X_latent_full) for i in range(0, latent_dim, 2): gen_func = lambda x: synthesize(x, [i, i + 1]) plot_grid(5, gen_func=gen_func, d=2, scale=.95, scatter=False, alpha=.7, c='k', fname='{}/assemblies{}'.format(results_dir, i / 2)) n_runs = 10 feasibility_func = import_module('{}.feasibility'.format( args.data)).check_feasibility prc_mean, prc_err = ci_prc(n_runs, model.synthesize_assemblies, feasibility_func, n_points) print('Precision for assembly: %.3f +/- %.3f' % (prc_mean, prc_err)) mmd_mean, mmd_err = ci_mmd(n_runs, model.synthesize_assemblies, X_test) rdiv_mean, rdiv_err = ci_rdiv(n_runs, X_test, model.synthesize_assemblies) basis = 'cartesian' cons_mean, cons_err = ci_cons(n_runs,
def train(self, X_train, train_steps=2000, batch_size=256, save_interval=0, directory='.'): X_train = preprocess(X_train) # Inputs self.x = tf.placeholder(tf.float32, shape=(None, ) + self.X_shape, name='real_image') self.c = tf.placeholder(tf.float32, shape=[None, self.latent_dim], name='latent_code') self.z = tf.placeholder(tf.float32, shape=[None, self.noise_dim], name='noise') # Targets q_target = tf.placeholder(tf.float32, shape=[None, self.latent_dim]) # Outputs d_real, _ = self.discriminator(self.x) x_fake_train, cp_train, w_train, ub_train, db_train = self.generator( self.c, self.z) d_fake, q_fake_train = self.discriminator(x_fake_train) self.x_fake_test, self.cp, self.w, ub, db = self.generator( self.c, self.z, training=False) _, self.q_test = self.discriminator(self.x, training=False) # Losses # Cross entropy losses for D d_loss_real = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=d_real, labels=tf.ones_like(d_real))) d_loss_fake = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=d_fake, labels=tf.zeros_like(d_fake))) # Cross entropy losses for G g_loss = tf.reduce_mean( tf.nn.sigmoid_cross_entropy_with_logits( logits=d_fake, labels=tf.ones_like(d_fake))) # Regularization for w, cp, a, and b r_w_loss = tf.reduce_mean(w_train[:, 1:-1], axis=[1, 2]) cp_dist = tf.norm(cp_train[:, 1:] - cp_train[:, :-1], axis=-1) r_cp_loss = tf.reduce_mean(cp_dist, axis=-1) r_cp_loss1 = tf.reduce_max(cp_dist, axis=-1) ends = cp_train[:, 0] - cp_train[:, -1] r_ends_loss = tf.norm(ends, axis=-1) + tf.maximum( 0.0, -10 * ends[:, 1]) r_db_loss = tf.reduce_mean(db_train * tf.log(db_train), axis=-1) r_loss = r_w_loss + r_cp_loss + 0 * r_cp_loss1 + r_ends_loss + 0 * r_db_loss r_loss = tf.reduce_mean(r_loss) # Gaussian loss for Q q_mean = q_fake_train[:, 0, :] q_logstd = q_fake_train[:, 1, :] epsilon = (q_target - q_mean) / (tf.exp(q_logstd) + EPSILON) q_loss = q_logstd + 0.5 * tf.square(epsilon) q_loss = tf.reduce_mean(q_loss) # Optimizers d_optimizer = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.5) g_optimizer = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.5) # Generator variables gen_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator') # Discriminator variables dis_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator') # Training operations d_train_real = d_optimizer.minimize(d_loss_real, var_list=dis_vars) d_train_fake = d_optimizer.minimize(d_loss_fake + q_loss, var_list=dis_vars) g_train = g_optimizer.minimize(g_loss + 10 * r_loss + q_loss, var_list=gen_vars) # def clip_gradient(optimizer, loss, var_list): # grads_and_vars = optimizer.compute_gradients(loss, var_list) # clipped_grads_and_vars = [(grad, var) if grad is None else # (tf.clip_by_value(grad, -1., 1.), var) for grad, var in grads_and_vars] # train_op = optimizer.apply_gradients(clipped_grads_and_vars) # return train_op # # d_train_real = clip_gradient(d_optimizer, d_loss_real, dis_vars) # d_train_fake = clip_gradient(d_optimizer, d_loss_fake + q_loss, dis_vars) # g_train = clip_gradient(g_optimizer, g_loss + q_loss, gen_vars) # Initialize the variables (i.e. assign their default value) init = tf.global_variables_initializer() # Create summaries to monitor losses tf.summary.scalar('D_loss_for_real', d_loss_real) tf.summary.scalar('D_loss_for_fake', d_loss_fake) tf.summary.scalar('G_loss', g_loss) tf.summary.scalar('R_loss', r_loss) tf.summary.scalar('Q_loss', q_loss) # Merge all summaries into a single op merged_summary_op = tf.summary.merge_all() # Add ops to save and restore all the variables. saver = tf.train.Saver() # Start training self.sess = tf.Session() # Run the initializer self.sess.run(init) # op to write logs to Tensorboard summary_writer = tf.summary.FileWriter('{}/logs'.format(directory), graph=self.sess.graph) for t in range(train_steps): ind = np.random.choice(X_train.shape[0], size=batch_size, replace=False) X_real = X_train[ind] _, dlr = self.sess.run([d_train_real, d_loss_real], feed_dict={self.x: X_real}) y_latent = np.random.uniform(low=self.bounds[0], high=self.bounds[1], size=(batch_size, self.latent_dim)) noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim)) X_fake = self.sess.run(self.x_fake_test, feed_dict={ self.c: y_latent, self.z: noise }) if np.any(np.isnan(X_fake)): ind = np.any(np.isnan(X_fake), axis=(1, 2, 3)) print( self.sess.run(ub, feed_dict={ self.c: y_latent, self.z: noise })[ind]) assert not np.any(np.isnan(X_fake)) _, dlf, qdl = self.sess.run([d_train_fake, d_loss_fake, q_loss], feed_dict={ x_fake_train: X_fake, q_target: y_latent }) y_latent = np.random.uniform(low=self.bounds[0], high=self.bounds[1], size=(batch_size, self.latent_dim)) noise = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim)) _, gl, rl, qgl = self.sess.run([g_train, g_loss, r_loss, q_loss], feed_dict={ self.c: y_latent, self.z: noise, q_target: y_latent }) summary_str = self.sess.run(merged_summary_op, feed_dict={ self.x: X_real, x_fake_train: X_fake, self.c: y_latent, self.z: noise, q_target: y_latent }) summary_writer.add_summary(summary_str, t + 1) # Show messages log_mesg = "%d: [D] real %f fake %f q %f" % (t + 1, dlr, dlf, qdl) log_mesg = "%s [G] fake %f reg %f q %f" % (log_mesg, gl, rl, qgl) print(log_mesg) if save_interval > 0 and (t + 1) % save_interval == 0: # from matplotlib import pyplot as plt # # ub_batch, db_batch = self.sess.run([ub, db], feed_dict={self.c: y_latent, self.z: noise}) # # xx = np.linspace(0, 1, self.X_shape[0]) # plt.figure() # for u in np.squeeze(ub_batch): # plt.plot(xx, u) # plt.savefig('{}/ub.svg'.format(directory)) # # plt.figure() # for d in db_batch: # plt.plot(xx[:-1], d) # plt.savefig('{}/db.svg'.format(directory)) # Save the variables to disk. save_path = saver.save(self.sess, '{}/model'.format(directory)) print('Model saved in path: %s' % save_path) print('Plotting results ...') plot_grid(5, gen_func=self.synthesize, d=self.latent_dim, bounds=self.bounds, scale=.95, scatter=True, s=1, alpha=.7, fname='{}/synthesized'.format(directory)) # Save the final variables to disk. save_path = saver.save(self.sess, '{}/model'.format(directory)) print('Model saved in path: %s' % save_path)
model = GAN(latent_dim, noise_dim, X_train.shape[1], bezier_degree, bounds) if args.mode == 'train': timer = ElapsedTimer() model.train(X_train, batch_size=batch_size, train_steps=train_steps, save_interval=args.save_interval, directory=directory) elapsed_time = timer.elapsed_time() runtime_mesg = 'Wall clock time for training: %s' % elapsed_time print(runtime_mesg) runtime_file = open('{}/runtime.txt'.format(directory), 'w') runtime_file.write('%s\n' % runtime_mesg) runtime_file.close() else: model.restore(directory=directory) print('Plotting synthesized shapes ...') points_per_axis = 5 plot_grid(points_per_axis, gen_func=model.synthesize, d=latent_dim, bounds=bounds, scale=1.0, scatter=False, symm_axis=symm_axis, alpha=.7, lw=1.2, c='k', fname='{}/synthesized'.format(directory)) def synthesize_noise(noise): return model.synthesize(0.5*np.ones((points_per_axis**2, latent_dim)), noise) plot_grid(points_per_axis, gen_func=synthesize_noise, d=noise_dim, bounds=(-1., 1.), scale=1.0, scatter=False, symm_axis=symm_axis, alpha=.7, lw=1.2, c='k', fname='{}/synthesized_noise'.format(directory)) n_runs = 10 mmd_mean, mmd_err = ci_mmd(n_runs, model.synthesize, X_test) cons_mean, cons_err = ci_cons(n_runs, model.synthesize, latent_dim, bounds) results_mesg_1 = 'Maximum mean discrepancy: %.4f +/- %.4f' % (mmd_mean, mmd_err) results_mesg_2 = 'Consistency: %.3f +/- %.3f' % (cons_mean, cons_err) results_file = open('{}/results.txt'.format(directory), 'w')
runtime_mesg = 'Wall clock time: %s' % elapsed_time print(runtime_mesg) print('Plotting training samples ...') samples1 = np.squeeze(X)[:64, :100] samples2 = np.squeeze(X)[:64, 100:] shape_plot.plot_samples(None, samples1, samples2, save_path='%s/samples.svg' % args.data) print('Plotting synthesized parent ...') shape_plot.plot_grid(5, gen_func=hgan.synthesize_parent, d=latent_dim, scale=.95, save_path='%s/%s/parent.svg' % (args.data, args.model)) print('Plotting synthesized child ...') shape_plot.plot_grid(5, gen_func=hgan.synthesize_child, d=latent_dim, scale=.95, save_path='%s/%s/child.svg' % (args.data, args.model)) n_runs = 10 mll_mean, mll_err = ci_mll(n_runs, hgan.synthesize_assembly, X_test) rssim_mean, rssim_err = ci_rssim(n_runs, X_train, hgan.synthesize_assembly) cons1_mean, cons1_err = ci_cons(n_runs, hgan.synthesize_parent)
def train(self, train_steps=2000, batch_size=256, save_interval=0, mode='startover'): g1_fname = '../hgan_idetc2018_data/superformula/2g1d/generator1.h5' g2_fname = '../hgan_idetc2018_data/superformula/2g1d/generator2.h5' d_fname = '../hgan_idetc2018_data/superformula/2g1d/discriminator.h5' if os.path.isfile(g1_fname) and os.path.isfile( g2_fname) and os.path.isfile(d_fname): trained_existed = True else: trained_existed = False if mode != 'startover' and trained_existed: self.dis = self.D = load_model(d_fname) self.gen1 = self.G1 = load_model(g1_fname) self.gen2 = self.G2 = load_model(g2_fname) else: self.dis = self.discriminator() self.gen1 = self.generator1() self.gen2 = self.generator2() self.dis_model = self.discriminator_model() self.adv_model1 = self.adversarial_model1() self.adv_model2 = self.adversarial_model2() if mode != 'evaluate' or not trained_existed: losses = dict() losses['d_loss_real'] = [] losses['d_loss_fake'] = [] losses['g_loss_parent'] = [] losses['g_loss_child'] = [] losses['q_loss_parent'] = [] losses['q_loss_child'] = [] for t in range(train_steps): sigma = np.exp(-t / 1e4) # annealed noise scale # Train discriminator model and adversarial model ind = np.random.choice(self.x_train.shape[0], size=batch_size, replace=False) X_train = self.x_train[ind] X_train += np.random.normal(scale=sigma, size=X_train.shape) y_real = np.zeros((batch_size, 2), dtype=np.uint8) y_real[:, 1] = 1 # y_real = label_flipping(y_real, .1) y_latent1 = np.random.uniform(size=(batch_size, self.latent_dim)) y_latent_target1 = np.expand_dims(y_latent1, 1) y_latent_target1 = np.repeat(y_latent_target1, 2, axis=1) y_latent2 = np.random.uniform(size=(batch_size, self.latent_dim)) y_latent_target2 = np.expand_dims(y_latent2, 1) y_latent_target2 = np.repeat(y_latent_target2, 2, axis=1) d_loss_real = self.dis_model.train_on_batch( X_train, [y_real, y_latent_target1, y_latent_target2]) noise1 = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim)) noise2 = np.random.normal(scale=0.5, size=(batch_size, self.noise_dim)) y_latent1 = np.random.uniform(size=(batch_size, self.latent_dim)) y_latent_target1 = np.expand_dims(y_latent1, 1) y_latent_target1 = np.repeat(y_latent_target1, 2, axis=1) y_latent2 = np.random.uniform(size=(batch_size, self.latent_dim)) y_latent_target2 = np.expand_dims(y_latent2, 1) y_latent_target2 = np.repeat(y_latent_target2, 2, axis=1) X1_fake = self.gen1.predict_on_batch([y_latent1, noise1]) X2_fake = self.gen2.predict_on_batch( [y_latent2, noise2, X1_fake]) X_fake = np.concatenate((X1_fake, X2_fake), axis=1) X_fake += np.random.normal(scale=sigma, size=X_fake.shape) y_fake = np.zeros((batch_size, 2), dtype=np.uint8) y_fake[:, 0] = 1 # y_fake = label_flipping(y_fake, .1) d_loss_fake = self.dis_model.train_on_batch( X_fake, [y_fake, y_latent_target1, y_latent_target2]) a1_loss = self.adv_model1.train_on_batch( [y_latent1, noise1, y_latent2, noise2], [y_real, y_latent_target1, y_latent_target2]) a2_loss = self.adv_model2.train_on_batch( [y_latent2, noise2, X1_fake], [y_real, y_latent_target1, y_latent_target2]) log_mesg = "%d: [D] real %f fake %f latent1 %f latent2 %f" % ( t + 1, d_loss_real[1], d_loss_fake[1], d_loss_fake[2], d_loss_fake[3]) log_mesg = "%s [A1] fake %f latent1 %f" % ( log_mesg, a1_loss[1], a1_loss[2]) log_mesg = "%s [A2] fake %f latent2 %f" % ( log_mesg, a2_loss[1], a2_loss[3]) print(log_mesg) losses['d_loss_real'].append(d_loss_real[1]) losses['d_loss_fake'].append(d_loss_fake[1]) losses['g_loss_parent'].append(a1_loss[1]) losses['g_loss_child'].append(a2_loss[1]) losses['q_loss_parent'].append(a1_loss[2]) losses['q_loss_child'].append(a2_loss[3]) if save_interval > 0 and (t + 1) % save_interval == 0: self.gen1.save(g1_fname) self.gen2.save(g2_fname) self.dis.save(d_fname) with open( '../hgan_idetc2018_data/superformula/2g1d/losses.pkl', 'wb') as f: pickle.dump(losses, f, pickle.HIGHEST_PROTOCOL) print 'Plotting results ...' from shape_plot import plot_grid plot_grid(9, gen_func=self.synthesize_parent, d=self.latent_dim, scale=.85, save_path='superformula/2g1d/parent.svg') plot_grid(9, gen_func=self.synthesize_child, d=self.latent_dim, scale=.85, save_path='superformula/2g1d/child.svg')
# Train model = GAN(latent_dim, noise_dim, X_train.shape[1], bezier_degree, bounds) if args.mode == 'startover': timer = ElapsedTimer() model.train(X_train, batch_size=batch_size, train_steps=train_steps, save_interval=args.save_interval) elapsed_time = timer.elapsed_time() runtime_mesg = 'Wall clock time for training: %s' % elapsed_time print(runtime_mesg) runtime_file = open('gan/runtime.txt', 'w') runtime_file.write('%s\n' % runtime_mesg) runtime_file.close() else: model.restore() print('Plotting synthesized shapes ...') plot_grid(5, gen_func=model.synthesize, d=latent_dim, bounds=bounds, scale=1.0, scatter=False, symm_axis=symm_axis, alpha=.7, lw=1.2, c='k', fname='gan/synthesized') n_runs = 10 mll_mean, mll_err = ci_mll(n_runs, model.synthesize, X_test) rdiv_mean, rdiv_err = ci_rdiv(n_runs, X, model.synthesize) cons_mean, cons_err = ci_cons(n_runs, model.synthesize, latent_dim, bounds) # Only for GANs rsmth_mean, rsmth_err = ci_rsmth(n_runs, model.synthesize, X_test) results_mesg_1 = 'Mean log likelihood: %.1f +/- %.1f' % (mll_mean, mll_err) results_mesg_2 = 'Relative diversity: %.3f +/- %.3f' % (rdiv_mean, rdiv_err) results_mesg_3 = 'Consistency: %.3f +/- %.3f' % (cons_mean, cons_err) results_mesg_4 = 'Smoothness: %.3f +/- %.3f' % (rsmth_mean, rsmth_err) results_file = open('gan/results.txt', 'w')
def train_model(X, X_l, fs, kwargs, intr_dim, dim_F, train, test, c, save_dir, dim_increase, source): ''' Build model instances using optimized hyperparameters and evaluate using test data ''' F = np.zeros((X.shape[0], dim_F)) F_norm = np.zeros_like(F) sum_test_errs = [] sum_test_gdis = [] geo_X = get_geo_dist(X_l) for f in fs: print 'Training ...' # Get semantic features F, name, inv_transform = f(X_l, dim_F, train, test, c=c, **kwargs[f.__name__]) # Get reconstructed data X_rec = dim_increase(inv_transform(F)) create_dir(save_dir + name) # Preprocess semantic features before plotting F_norm, transforms_F = preprocess_features(F) # Save the models for transfering features save_model(transforms_F[0], name + '_fpca', c) save_model(transforms_F[1], name + '_fscaler', c) # Convex hull of training samples in the semantic space if dim_F > 1: hull = ConvexHull(F_norm[train]) boundary = hull.equations save_array(boundary, name + '_boundary', c) else: boundary = None # Get semantic space sparsity kde = KernelDensity(kernel='epanechnikov', bandwidth=0.15).fit(F_norm[train]) print('Saving 2D plots for ' + name + ' ... ') if source == 'glass': shape_plot.plot_samples(F_norm, X, X_rec, train, test, save_dir, name, c) else: shape_plot.plot_samples(F_norm, X, X_rec, train, test, save_dir, name, c, mirror=False) if dim_F < 4: if source == 'glass': shape_plot.plot_grid(7, dim_F, inv_transform, dim_increase, transforms_F, save_dir, name, c, boundary, kde) else: shape_plot.plot_grid(7, dim_F, inv_transform, dim_increase, transforms_F, save_dir, name, c, boundary, kde, mirror=False) np.savetxt(save_dir + name + '_' + str(c) + '.csv', F, delimiter=",") # Get reconstruction error train_err = smape(X[train], X_rec[train]) test_err = smape(X[test], X_rec[test]) print 'Training error: ', train_err print 'Testing error: ', test_err sum_test_errs.append(len(test) * test_err) # Get topological metrics gdi = geo_dist_inconsistency( geo_X, F, X_precomputed=True) # computed for the entire dataset print 'GDI: ', gdi sum_test_gdis.append(X.shape[0] * gdi) return sum_test_errs, sum_test_gdis