] + 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
