# Visualize data
visualize_2d(data, func_obj, save_path='{}/data.svg'.format(example_dir), xlim=(-0.5,0.5), ylim=(-0.5,0.5))
visualize_2d(data, func_obj, save_path='{}/data.png'.format(example_dir), xlim=(-0.5,0.5), ylim=(-0.5,0.5))
# Train
model = GAN(noise_dim, 2, lambda0, lambda1)
if args.mode == 'train':
timer = ElapsedTimer()
model.train(data_obj, func_obj, batch_size=batch_size, train_steps=train_steps,
disc_lr=disc_lr, gen_lr=gen_lr, save_interval=save_interval, save_dir=save_dir)
elapsed_time = timer.elapsed_time()
runtime_mesg = 'Wall clock time for training: %s' % elapsed_time
print(runtime_mesg)
else:
model.restore(save_dir=save_dir)
print('##########################################################################')
print('Plotting generated samples ...')
# Plot generated samples
n = 1000
gen_data = model.synthesize(n)
visualize_2d(data[:n], func_obj, gen_data=gen_data, save_path='{}/synthesized.svg'.format(save_dir),
xlim=(-0.5,0.5), ylim=(-0.5,0.5), axis_off=False)
visualize_2d(data[:n], func_obj, gen_data=gen_data, save_path='{}/synthesized.png'.format(save_dir),
xlim=(-0.5,0.5), ylim=(-0.5,0.5), axis_off=False)
print('##########################################################################')
print('Plotting quality distribution ...')
parser.add_argument('--n_eval', type=int, default=1000, help='number of evaluations per run')
args = parser.parse_args()
n_runs = args.n_runs
n_eval = args.n_eval
# Airfoil parameters
latent_dim = 3
noise_dim = 10
n_points = 192
bezier_degree = 32
bounds = (0., 1.)
# Restore trained model
model = GAN(latent_dim, noise_dim, n_points, bezier_degree, bounds)
model.restore()
opt_airfoil_runs = []
opt_perfs_runs = []
time_runs = []
for i in range(n_runs):
start_time = time.time()
opt_airfoil, opt_perfs = optimize(latent_dim, bounds, n_eval, i+1)
end_time = time.time()
opt_airfoil_runs.append(opt_airfoil)
opt_perfs_runs.append(opt_perfs)
time_runs.append(end_time-start_time)
opt_airfoil_runs = np.array(opt_airfoil_runs)
opt_perfs_runs = np.array(opt_perfs_runs)
np.save('opt_results/gan_bo/opt_airfoil.npy', opt_airfoil_runs)
# Train
directory = './trained_gan/{}_{}'.format(latent_dim, noise_dim)
if args.model_id is not None:
directory += '/{}'.format(args.model_id)
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)
