def evaluate_recon(sess, dcgan, args, dataset, train_iter):
for (gi, ei), recon in dcgan.reconstructers.items():
for c in range(dataset.num_classes):
inputs_c, _ = dataset.next_batch(args.batch_size, class_id=c)
recons_c = sess.run(recon, feed_dict={dcgan.inputs: inputs_c})
filename = "B_DCGAN_RECON_g%i_e%i_c%i" % (gi, ei, c)
print_images(recons_c,
filename,
train_iter,
directory=args.out_dir)
def b_dcgan(dataset, args):
z_dim = args.z_dim
x_dim = dataset.x_dim
batch_size = args.batch_size
dataset_size = dataset.dataset_size
session = get_session()
tf.set_random_seed(args.random_seed)
# due to how much the TF code sucks all functions take fixed batch_size at all times
dcgan = BDCGAN_Semi(x_dim,
z_dim,
dataset_size,
batch_size=batch_size,
J=args.J,
J_d=args.J_d,
M=args.M,
num_layers=args.num_layers,
lr=args.lr,
optimizer=args.optimizer,
gf_dim=args.gf_dim,
df_dim=args.df_dim,
ml=(args.ml and args.J == 1 and args.M == 1
and args.J_d == 1),
num_classes=dataset.num_classes)
print "Starting session"
session.run(tf.global_variables_initializer())
print "Starting training loop"
num_train_iter = args.train_iter
if hasattr(dataset, "supervised_batches"):
# implement own data feeder if data doesnt fit in memory
supervised_batches = dataset.supervised_batches(args.N, batch_size)
else:
supervised_batches = get_supervised_batches(dataset, args.N,
batch_size,
range(dataset.num_classes))
test_image_batches, test_label_batches = get_test_batches(
dataset, batch_size)
optimizer_dict = {
"disc_semi": dcgan.d_optims_semi_adam,
"sup_d": dcgan.s_optim_adam,
"gen": dcgan.g_optims_semi_adam
}
base_learning_rate = args.lr # for now we use same learning rate for Ds and Gs
lr_decay_rate = args.lr_decay
num_disc = args.J_d
for train_iter in range(num_train_iter):
if train_iter == 5000:
print "Switching to user-specified optimizer"
optimizer_dict = {
"disc_semi": dcgan.d_optims_semi,
"sup_d": dcgan.s_optim,
"gen": dcgan.g_optims_semi
}
learning_rate = base_learning_rate * np.exp(-lr_decay_rate * min(
1.0, (train_iter * batch_size) / float(dataset_size)))
image_batch, _ = dataset.next_batch(batch_size, class_id=None)
labeled_image_batch, labels = supervised_batches.next()
### compute disc losses
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim, dcgan.num_gen])
disc_info = session.run(
optimizer_dict["disc_semi"] +
dcgan.d_losses, # + [dcgan.d_probs] + [dcgan.d_hh],
feed_dict={
dcgan.labeled_inputs: labeled_image_batch,
dcgan.labels: labels,
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_semi_learning_rate: learning_rate
})
d_losses = disc_info[num_disc:num_disc * 2]
#print disc_info[num_disc*2:num_disc*3][0][:, 0]
### compute generative losses
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim, dcgan.num_gen])
gen_info = session.run(optimizer_dict["gen"] + dcgan.g_losses,
feed_dict={
dcgan.z: batch_z,
dcgan.inputs: image_batch,
dcgan.g_learning_rate: learning_rate
})
g_losses = [g_ for g_ in gen_info if g_ is not None]
### vanilla supervised loss
_, s_loss = session.run([optimizer_dict["sup_d"], dcgan.s_loss],
feed_dict={
dcgan.inputs: labeled_image_batch,
dcgan.lbls: labels
})
if train_iter > 0 and train_iter % args.n_save == 0:
print "Iter %i" % train_iter
print "Disc losses = %s" % (", ".join(
["%.2f" % dl for dl in d_losses]))
print "Gen losses = %s" % (", ".join(
["%.2f" % gl for gl in g_losses]))
# get test set performance on real labels only for both GAN-based classifier and standard one
s_acc, ss_acc = get_test_accuracy(session, dcgan,
test_image_batches,
test_label_batches)
print "Sup classification acc: %.2f" % (s_acc)
print "Semi-sup classification acc: %.2f" % (ss_acc)
print "saving results and samples"
results = {
"disc_losses": map(float, d_losses),
"gen_losses": map(float, g_losses),
"supervised_acc": float(s_acc),
"semi_supervised_acc": float(ss_acc),
"timestamp": time.time()
}
with open(
os.path.join(args.out_dir, 'results_%i.json' % train_iter),
'w') as fp:
json.dump(results, fp)
if args.save_samples:
for zi in xrange(dcgan.num_gen):
_imgs, _ps = [], []
for _ in range(10):
z_sampler = np.random.uniform(-1,
1,
size=(batch_size, z_dim))
sampled_imgs = session.run(
dcgan.gen_samplers[zi * dcgan.num_mcmc],
feed_dict={dcgan.z_sampler: z_sampler})
_imgs.append(sampled_imgs)
sampled_imgs = np.concatenate(_imgs)
print_images(sampled_imgs,
"B_DCGAN_%i_%.2f" %
(zi, g_losses[zi * dcgan.num_mcmc]),
train_iter,
directory=args.out_dir)
print_images(image_batch,
"RAW",
train_iter,
directory=args.out_dir)
if args.save_weights:
var_dict = {}
for var in tf.trainable_variables():
var_dict[var.name] = session.run(var.name)
np.savez_compressed(
os.path.join(args.out_dir, "weights_%i.npz" % train_iter),
**var_dict)
print "done"
def b_dcgan(dataset, args):
z_dim = args.z_dim
x_dim = dataset.x_dim
batch_size = args.batch_size
dataset_size = dataset.dataset_size
session = get_session()
tf.set_random_seed(args.random_seed)
dcgan = BDCGAN(x_dim,
z_dim,
dataset_size,
batch_size=batch_size,
J=args.J,
J_d=args.J_d,
M=args.M,
num_layers=args.num_layers,
lr=args.lr,
optimizer=args.optimizer,
gf_dim=args.gf_dim,
df_dim=args.df_dim,
ml=(args.ml and args.J == 1 and args.M == 1
and args.J_d == 1))
print "Starting session"
session.run(tf.global_variables_initializer())
print "Starting training loop"
num_train_iter = args.train_iter
optimizer_dict = {"disc": dcgan.d_optims_adam, "gen": dcgan.g_optims_adam}
base_learning_rate = args.lr # for now we use same learning rate for Ds and Gs
lr_decay_rate = args.lr_decay
num_disc = args.J_d
for train_iter in range(num_train_iter):
if train_iter == 5000:
print "Switching to user-specified optimizer"
optimizer_dict = {
"disc": dcgan.d_optims_adam,
"gen": dcgan.g_optims_adam
}
learning_rate = base_learning_rate * np.exp(-lr_decay_rate * min(
1.0, (train_iter * batch_size) / float(dataset_size)))
image_batch, _ = dataset.next_batch(batch_size, class_id=None)
### compute disc losses
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim, dcgan.num_gen])
disc_info = session.run(optimizer_dict["disc"] + dcgan.d_losses,
feed_dict={
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_learning_rate: learning_rate
})
d_losses = [d_ for d_ in disc_info if d_ is not None]
### compute generative losses
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim, dcgan.num_gen])
gen_info = session.run(optimizer_dict["gen"] + dcgan.g_losses,
feed_dict={
dcgan.z: batch_z,
dcgan.inputs: image_batch,
dcgan.g_learning_rate: learning_rate
})
g_losses = [g_ for g_ in gen_info if g_ is not None]
if train_iter > 0 and train_iter % args.n_save == 0:
print "Iter %i" % train_iter
print "Disc losses = %s" % (", ".join(
["%.2f" % dl for dl in d_losses]))
print "Gen losses = %s" % (", ".join(
["%.2f" % gl for gl in g_losses]))
print "saving results and samples"
results = {
"disc_losses": map(float, d_losses),
"gen_losses": map(float, g_losses),
"timestamp": time.time()
}
with open(
os.path.join(args.out_dir, 'results_%i.json' % train_iter),
'w') as fp:
json.dump(results, fp)
if args.save_samples:
for zi in xrange(dcgan.num_gen):
_imgs, _ps = [], []
for _ in range(10):
z_sampler = np.random.uniform(-1,
1,
size=(batch_size, z_dim))
sampled_imgs = session.run(
dcgan.gen_samplers[zi * dcgan.num_mcmc],
feed_dict={dcgan.z_sampler: z_sampler})
_imgs.append(sampled_imgs)
sampled_imgs = np.concatenate(_imgs)
print_images(sampled_imgs,
"B_DCGAN_%i_%.2f" %
(zi, g_losses[zi * dcgan.num_mcmc]),
train_iter,
directory=args.out_dir)
print_images(image_batch,
"RAW",
train_iter,
directory=args.out_dir)
if args.save_weights:
var_dict = {}
for var in tf.trainable_variables():
var_dict[var.name] = session.run(var.name)
np.savez_compressed(
os.path.join(args.out_dir, "weights_%i.npz" % train_iter),
**var_dict)
print "done"
def b_dcgan(dataset, args):
z_dim = args.z_dim
x_dim = dataset.x_dim
batch_size = args.batch_size
dataset_size = dataset.dataset_size
session = get_session()
test_x = tf.placeholder(tf.float32, shape=(batch_size, 28, 28, 1))
x = tf.placeholder(tf.float32, shape=(batch_size, 28, 28, 1))
y = tf.placeholder(tf.float32, shape=(batch_size, 10))
unlabeled_batch_ph = tf.placeholder(tf.float32,
shape=(batch_size, 28, 28, 1))
labeled_image_ph = tf.placeholder(tf.float32,
shape=(batch_size, 28, 28, 1))
if args.random_seed is not None:
tf.set_random_seed(args.random_seed)
# due to how much the TF code sucks all functions take fixed batch_size at all times
dcgan = BDCGAN(
x_dim,
z_dim,
dataset_size,
batch_size=batch_size,
J=args.J,
M=args.M,
lr=args.lr,
optimizer=args.optimizer,
gen_observed=args.gen_observed,
adv_train=args.adv_train,
num_classes=dataset.num_classes if args.semi_supervised else 1)
if args.adv_test and args.semi_supervised:
if args.basic_iterative:
fgsm = BasicIterativeMethod(dcgan, sess=session)
dcgan.adv_constructor = fgsm
fgsm_params = {
'eps': args.eps,
'eps_iter': float(args.eps / 4),
'nb_iter': 4,
'ord': np.inf,
'clip_min': 0.,
'clip_max': 1.
}
#,'y_target': None}
else:
fgsm = FastGradientMethod(dcgan, sess=session)
dcgan.adv_constructor = fgsm
eval_params = {'batch_size': batch_size}
fgsm_params = {'eps': args.eps, 'clip_min': 0., 'clip_max': 1.}
adv_x = fgsm.generate(x, **fgsm_params)
adv_test_x = fgsm.generate(test_x, **fgsm_params)
preds = dcgan.get_probs(adv_x)
if args.adv_train:
unlabeled_targets = np.zeros([batch_size, dcgan.K + 1])
unlabeled_targets[:, 0] = 1
fgsm_targeted_params = {
'eps': args.eps,
'clip_min': 0.,
'clip_max': 1.,
'y_target': unlabeled_targets
}
saver = tf.train.Saver()
print("Starting session")
session.run(tf.global_variables_initializer())
prev_iters = 0
if args.load_chkpt:
saver.restore(session, args.chkpt)
# Assume checkpoint is of the form "model_300"
prev_iters = int(args.chkpt.split('/')[-1].split('_')[1])
print("Model restored from iteration:", prev_iters)
print("Starting training loop")
num_train_iter = args.train_iter
if hasattr(dataset, "supervised_batches"):
# implement own data feeder if data doesnt fit in memory
supervised_batches = dataset.supervised_batches(args.N, batch_size)
else:
supervised_batches = get_supervised_batches(
dataset, args.N, batch_size, list(range(dataset.num_classes)))
if args.semi_supervised:
test_image_batches, test_label_batches = get_test_batches(
dataset, batch_size)
optimizer_dict = {
"semi_d": dcgan.d_optim_semi_adam,
"sup_d": dcgan.s_optim_adam,
"adv_d": dcgan.d_optim_adam,
"gen": dcgan.g_optims_adam
}
else:
optimizer_dict = {
"adv_d": dcgan.d_optim_adam,
"gen": dcgan.g_optims_adam
}
base_learning_rate = args.lr # for now we use same learning rate for Ds and Gs
lr_decay_rate = args.lr_decay
for train_iter in range(1 + prev_iters, 1 + num_train_iter):
if train_iter == 5000:
print("Switching to user-specified optimizer")
if args.semi_supervised:
optimizer_dict = {
"semi_d": dcgan.d_optim_semi,
"sup_d": dcgan.s_optim,
"adv_d": dcgan.d_optim,
"gen": dcgan.g_optims
}
else:
optimizer_dict = {
"adv_d": dcgan.d_optim,
"gen": dcgan.g_optims
}
learning_rate = base_learning_rate * np.exp(-lr_decay_rate * min(
1.0, (train_iter * batch_size) / float(dataset_size)))
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim])
image_batch, batch_label = dataset.next_batch(batch_size,
class_id=None)
batch_targets = np.zeros([batch_size, 11])
batch_targets[:, 0] = 1
if args.semi_supervised:
labeled_image_batch, labels = next(supervised_batches)
if args.adv_train:
adv_labeled = session.run(
fgsm.generate(labeled_image_ph, **fgsm_targeted_params),
feed_dict={labeled_image_ph: labeled_image_batch})
adv_unlabeled = session.run(
fgsm.generate(unlabeled_batch_ph, **fgsm_params),
feed_dict={unlabeled_batch_ph: image_batch})
_, d_loss = session.run(
[optimizer_dict["semi_d"], dcgan.d_loss_semi],
feed_dict={
dcgan.labeled_inputs: labeled_image_batch,
dcgan.labels: get_gan_labels(labels),
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_semi_learning_rate: learning_rate,
dcgan.adv_unlab: adv_unlabeled,
dcgan.adv_labeled: adv_labeled
})
else:
_, d_loss = session.run(
[optimizer_dict["semi_d"], dcgan.d_loss_semi],
feed_dict={
dcgan.labeled_inputs: labeled_image_batch,
dcgan.labels: get_gan_labels(labels),
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_semi_learning_rate: learning_rate
})
_, s_loss = session.run([optimizer_dict["sup_d"], dcgan.s_loss],
feed_dict={
dcgan.inputs: labeled_image_batch,
dcgan.lbls: labels
})
else:
# regular GAN
_, d_loss = session.run(
[optimizer_dict["adv_d"], dcgan.d_loss],
feed_dict={
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_learning_rate: learning_rate
})
if args.wasserstein:
session.run(dcgan.clip_d, feed_dict={})
g_losses = []
for gi in range(dcgan.num_gen):
# compute g_sample loss
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim])
for m in range(dcgan.num_mcmc):
_, g_loss = session.run([
optimizer_dict["gen"][gi * dcgan.num_mcmc + m],
dcgan.generation["g_losses"][gi * dcgan.num_mcmc + m]
],
feed_dict={
dcgan.z: batch_z,
dcgan.g_learning_rate:
learning_rate
})
g_losses.append(g_loss)
# if args.adv_test:
# probs, logits = dcgan.discriminator(adv_x,dcgan.K+1,reuse = True)
# labels = tf.placeholder(tf.float32,
# [args.batch_size, dcgan.K+1], name='real_targets')
# compare_labels = tf.convert_to_tensor(np.array([np.append(0,i) for i in batch_label]))
# print(session.run(model_loss(compare_labels,probs), feed_dict = {x:image_batch}))
# if args.adv_test:
# #preds = dcgan.get_probs(adv_x)
# #eval_preds = session.run(preds, feed_dict = {x:image_batch})
# #print(eval_preds[0])
# #adv_exs = session.run(adv_test_x, feed_dict = {x:test_image_batches})
# # adv_acc = model_eval(
# # session, x, y, preds, image_batch, batch_label, args=eval_params)
# # #print(session.run(model_loss(compare_labels,probs), feed_dict = {x:image_batch}))
# # print("Adversarial loss = %2.f" % (1-adv_acc))
# print(get_test_accuracy(session,dcgan,adv_set,test_label_batches))
if train_iter > 0 and train_iter % args.n_save == 0:
print("Iter %i" % train_iter)
# collect samples
if args.save_samples: # saving samples
all_sampled_imgs = []
for gi in range(dcgan.num_gen):
_imgs, _ps = [], []
for _ in range(10):
sample_z = np.random.uniform(-1,
1,
size=(batch_size, z_dim))
sampled_imgs, sampled_probs = session.run([
dcgan.generation["gen_samplers"][gi *
dcgan.num_mcmc],
dcgan.generation["d_probs"][gi * dcgan.num_mcmc]
],
feed_dict={
dcgan.z:
sample_z
})
_imgs.append(sampled_imgs)
_ps.append(sampled_probs)
sampled_imgs = np.concatenate(_imgs)
sampled_probs = np.concatenate(_ps)
all_sampled_imgs.append(
[sampled_imgs, sampled_probs[:, 1:].sum(1)])
print("Disc loss = %.2f, Gen loss = %s" %
(d_loss, ", ".join(["%.2f" % gl for gl in g_losses])))
#if args.adv_test:
#preds = dcgan.get_probs(adv_x)
#eval_preds = session.run(preds, feed_dict = {x:image_batch})
#print(eval_preds[0])
#adv_exs = session.run(adv_test_x, feed_dict = {x:test_image_batches})
# adv_acc = model_eval(
# session, x, y, preds, image_batch, batch_label, args=eval_params)
# #print(session.run(model_loss(compare_labels,probs), feed_dict = {x:image_batch}))
# print("Adversarial loss = %2.f" % (1-adv_acc))
#print(get_test_accuracy(session,dcgan,adv_set,test_label_batches))
# adv_x = fgsm.generate(x,**fgsm_params)
# preds = dcgan.get_probs(adv_x)
# acc = model_eval(
# session, x, y, preds, image_batch, batch_label, args=eval_params)
# print("Adversarial loss = %2.f" % (1-acc))
if args.semi_supervised:
# get test set performance on real labels only for both GAN-based classifier and standard one
s_acc, ss_acc, non_adv_acc, ex_prob = get_test_accuracy(
session, dcgan, test_image_batches, test_label_batches)
if args.adv_test:
adv_set = []
for test_images in test_image_batches:
adv_set.append(
session.run(adv_x, feed_dict={x: test_images}))
adv_sup_acc, adv_ss_acc, correct_uncertainty, incorrect_uncertainty, adv_acc, adv_ex_prob = get_adv_test_accuracy(
session, dcgan, adv_set, test_label_batches)
print("Adversarial semi-sup accuracy with filter: %.2f" %
adv_sup_acc)
print("Adverarial semi-sup accuracy: %.2f" % adv_ss_acc)
print("Uncertainty for correct predictions: %.2f" %
correct_uncertainty)
print("Uncertainty for incorrect predictions: %.2f" %
incorrect_uncertainty)
print("non_adversarial_classification_accuracy: %.2f" %
non_adv_acc)
print("adversarial_classification_accuracy: %.2f" %
adv_acc)
if args.save_samples:
print("saving adversarial test images and test images")
i = 0
for x, y in zip(adv_set[-1], test_image_batches[-1]):
np.save(
args.out_dir + '/adv_test' + str(train_iter) +
'_' + str(i), x)
np.save(
args.out_dir + '/test' + str(train_iter) +
'_' + str(i), y)
i = i + 1
if i == 5: #save 5 adversarial images
break
print("Supervised acc: %.2f" % (s_acc))
print("Semi-sup acc: %.2f" % (ss_acc))
print("saving results and samples")
results = {
"disc_loss": float(d_loss),
"gen_losses": list(map(float, g_losses))
}
if args.semi_supervised:
#results["example_non_adversarial_probs"] = list(ex_prob.flatten())
#results["example_adversarial_probs"] = list(adv_ex_prob.flatten())
results["non_adversarial_classification_accuracy"] = float(
non_adv_acc)
results["adversarial_classification_accuracy"] = float(adv_acc)
results["adversarial_uncertainty_correct"] = float(
correct_uncertainty)
results["adversarial_uncertainty_incorrect"] = float(
incorrect_uncertainty)
results["supervised_acc"] = float(s_acc)
results['adversarial_filtered_semi_supervised_acc'] = float(
adv_sup_acc)
results["adversarial_unfilted_semi_supervised_acc"] = float(
adv_ss_acc)
results["semi_supervised_acc"] = float(ss_acc)
results["timestamp"] = time.time()
results["previous_chkpt"] = args.chkpt
with open(
os.path.join(args.out_dir, 'results_%i.json' % train_iter),
'w') as fp:
json.dump(results, fp)
if args.save_samples:
for gi in range(dcgan.num_gen):
print_images(all_sampled_imgs[gi],
"B_DCGAN_%i_%.2f" %
(gi, g_losses[gi * dcgan.num_mcmc]),
train_iter,
directory=args.out_dir)
print_images(image_batch,
"RAW",
train_iter,
directory=args.out_dir)
if args.save_weights:
var_dict = {}
for var in tf.trainable_variables():
var_dict[var.name] = session.run(var.name)
np.savez_compressed(
os.path.join(args.out_dir, "weights_%i.npz" % train_iter),
**var_dict)
print("Done saving weights")
if train_iter > 0 and train_iter % args.save_chkpt == 0:
save_path = saver.save(
session, os.path.join(args.out_dir, "model_%i" % train_iter))
print("Model checkpointed in file: %s" % save_path)
session.close()
def b_dcgan(dataset, args):
z_dim = args.z_dim
x_dim = dataset.x_dim
batch_size = args.batch_size
dataset_size = dataset.dataset_size
session = get_session()
if args.random_seed is not None:
tf.set_random_seed(args.random_seed)
# due to how much the TF code sucks all functions take fixed batch_size at all times
dcgan = BDCGAN(
x_dim,
z_dim,
dataset_size,
batch_size=batch_size,
J=args.J,
M=args.M,
lr=args.lr,
optimizer=args.optimizer,
gen_observed=args.gen_observed,
num_classes=dataset.num_classes if args.semi_supervised else 1)
print("Starting session")
session.run(tf.global_variables_initializer())
print("Starting training loop")
num_train_iter = args.train_iter
if hasattr(dataset, "supervised_batches"):
# implement own data feeder if data doesnt fit in memory
supervised_batches = dataset.supervised_batches(args.N, batch_size)
else:
supervised_batches = get_supervised_batches(
dataset, args.N, batch_size, list(range(dataset.num_classes)))
test_image_batches, test_label_batches = get_test_batches(
dataset, batch_size)
optimizer_dict = {
"semi_d": dcgan.d_optim_semi_adam,
"sup_d": dcgan.s_optim_adam,
"adv_d": dcgan.d_optim_adam,
"gen": dcgan.g_optims_adam
}
base_learning_rate = args.lr # for now we use same learning rate for Ds and Gs
lr_decay_rate = args.lr_decay
for train_iter in range(num_train_iter):
if train_iter == 5000:
print("Switching to user-specified optimizer")
optimizer_dict = {
"semi_d": dcgan.d_optim_semi,
"sup_d": dcgan.s_optim,
"adv_d": dcgan.d_optim,
"gen": dcgan.g_optims
}
learning_rate = base_learning_rate * np.exp(-lr_decay_rate * min(
1.0, (train_iter * batch_size) / float(dataset_size)))
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim])
image_batch, _ = dataset.next_batch(batch_size, class_id=None)
if args.semi_supervised:
labeled_image_batch, labels = next(supervised_batches)
_, d_loss = session.run(
[optimizer_dict["semi_d"], dcgan.d_loss_semi],
feed_dict={
dcgan.labeled_inputs: labeled_image_batch,
dcgan.labels: get_gan_labels(labels),
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_semi_learning_rate: learning_rate
})
_, s_loss = session.run([optimizer_dict["sup_d"], dcgan.s_loss],
feed_dict={
dcgan.inputs: labeled_image_batch,
dcgan.lbls: labels
})
else:
# regular GAN
_, d_loss = session.run(
[optimizer_dict["adv_d"], dcgan.d_loss],
feed_dict={
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_learning_rate: learning_rate
})
if args.wasserstein:
session.run(dcgan.clip_d, feed_dict={})
g_losses = []
for gi in range(dcgan.num_gen):
# compute g_sample loss
batch_z = np.random.uniform(-1, 1, [batch_size, z_dim])
for m in range(dcgan.num_mcmc):
_, g_loss = session.run([
optimizer_dict["gen"][gi * dcgan.num_mcmc + m],
dcgan.generation["g_losses"][gi * dcgan.num_mcmc + m]
],
feed_dict={
dcgan.z: batch_z,
dcgan.g_learning_rate:
learning_rate
})
g_losses.append(g_loss)
if train_iter > 0 and train_iter % args.n_save == 0:
print("Iter %i" % train_iter)
# collect samples
if args.save_samples: # saving samples
all_sampled_imgs = []
for gi in range(dcgan.num_gen):
_imgs, _ps = [], []
for _ in range(10):
sample_z = np.random.uniform(-1,
1,
size=(batch_size, z_dim))
sampled_imgs, sampled_probs = session.run([
dcgan.generation["gen_samplers"][gi *
dcgan.num_mcmc],
dcgan.generation["d_probs"][gi * dcgan.num_mcmc]
],
feed_dict={
dcgan.z:
sample_z
})
_imgs.append(sampled_imgs)
_ps.append(sampled_probs)
sampled_imgs = np.concatenate(_imgs)
sampled_probs = np.concatenate(_ps)
all_sampled_imgs.append(
[sampled_imgs, sampled_probs[:, 1:].sum(1)])
print("Disc loss = %.2f, Gen loss = %s" %
(d_loss, ", ".join(["%.2f" % gl for gl in g_losses])))
if args.semi_supervised:
# get test set performance on real labels only for both GAN-based classifier and standard one
s_acc, ss_acc = get_test_accuracy(session, dcgan,
test_image_batches,
test_label_batches)
print("Sup classification acc: %.2f" % (s_acc))
print("Semi-sup classification acc: %.2f" % (ss_acc))
print("saving results and samples")
results = {
"disc_loss": float(d_loss),
"gen_losses": list(map(float, g_losses))
}
if args.semi_supervised:
results["supervised_acc"] = float(s_acc)
results["semi_supervised_acc"] = float(ss_acc)
results["timestamp"] = time.time()
with open(
os.path.join(args.out_dir, 'results_%i.json' % train_iter),
'w') as fp:
json.dump(results, fp)
if args.save_samples:
for gi in range(dcgan.num_gen):
print_images(all_sampled_imgs[gi],
"B_DCGAN_%i_%.2f" %
(gi, g_losses[gi * dcgan.num_mcmc]),
train_iter,
directory=args.out_dir)
print_images(image_batch,
"RAW",
train_iter,
directory=args.out_dir)
if args.save_weights:
var_dict = {}
for var in tf.trainable_variables():
var_dict[var.name] = session.run(var.name)
np.savez_compressed(
os.path.join(args.out_dir, "weights_%i.npz" % train_iter),
**var_dict)
print("done")
def train_dcgan(dataset, args, dcgan, sess):
print("Starting sess")
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
print("Starting training loop")
num_train_iter = args.train_iter
optimizer_dict = dcgan.opt_adam_dict
lr_decay_rate = args.lr_decay
num_disc = args.J_d
saver = tf.train.Saver()
running_losses = {}
for m in ["g", "e", "d_real", "d_fake", "recon"]:
running_losses["%s_losses" % m] = np.empty(num_train_iter)
running_losses["d_accuracy"] = np.empty(num_train_iter)
d_update_threshold = args.d_update_threshold
if args.d_update_decay_steps == "":
d_update_decay_steps = []
else:
d_update_decay_steps = list(
map(int, args.d_update_decay_steps.split(",")))
base_lrs = {}
base_lrs["g"] = args.gen_lr
base_lrs["e"] = args.enc_lr
base_lrs["d"] = args.disc_lr
lrs = {}
for k, v in base_lrs.items():
lrs[k] = v
d_lr = d_base_lr = args.disc_lr
for train_iter in range(num_train_iter):
for k, lr in base_lrs.items():
if k != "d":
continue
lrs[k] = lr * np.exp(-args.lr_decay * min(
1.0, train_iter * args.batch_size / dataset.dataset_size))
print('lrs', ', '.join("%s %.7f" % (k, lr) for k, lr in lrs.items()))
if train_iter == 5000:
print("Switching to user-specified optimizer")
optimizer_dict = dcgan.opt_user_dict
if (train_iter + 1) in d_update_decay_steps:
d_update_threshold = max(d_update_threshold - args.d_update_decay,
args.d_update_bound)
print("d update threshold:", d_update_threshold)
image_batch, _ = dataset.next_batch(args.batch_size, class_id=None)
### compute disc losses
batch_z = np.random.uniform(
-1, 1, [args.batch_size, args.z_dim, dcgan.num_gen])
#np.random.normal(0, 1, [args.batch_size, args.z_dim, dcgan.num_gen])
d_feed_dict = {
dcgan.inputs: image_batch,
dcgan.z: batch_z,
dcgan.d_learning_rate: lrs["d"]
}
d_losses_reals, d_losses_fakes = sess.run(
[dcgan.d_losses_reals, dcgan.d_losses_fakes],
feed_dict=d_feed_dict)
d_real_acc = sess.run(dcgan.d_acc_reals, feed_dict=d_feed_dict)
d_fake_acc = sess.run(dcgan.d_acc_fakes, feed_dict=d_feed_dict)
d_mean_acc = np.mean(np.concatenate((d_real_acc, d_fake_acc)))
if (args.disc_skip_update
and train_iter % 2) == 0 and d_mean_acc < d_update_threshold:
sess.run(optimizer_dict["disc"], feed_dict=d_feed_dict)
d_updated = True
else:
d_updated = False
### compute encoder losses
e_feed_dict = {
dcgan.inputs: image_batch,
dcgan.e_learning_rate: lrs["e"]
}
e_losses = sess.run(dcgan.e_losses, feed_dict=e_feed_dict)
if train_iter + 1 > args.e_optimize_iter:
sess.run(optimizer_dict["enc"], feed_dict=e_feed_dict)
### compute generative losses
batch_z = np.random.uniform(
-1, 1, [args.batch_size, args.z_dim, dcgan.num_gen])
g_feed_dict = {
dcgan.z: batch_z,
dcgan.inputs: image_batch,
dcgan.g_learning_rate: lrs["g"]
}
g_losses = sess.run(dcgan.g_losses, feed_dict=g_feed_dict)
sess.run(optimizer_dict["gen"], feed_dict=g_feed_dict)
recon_losses = sess.run(dcgan.recon_losses,
feed_dict={dcgan.inputs: image_batch})
print("Iter %i" % train_iter)
print_losses("Disc reals losses", d_losses_reals)
print_losses("Disc fakes losses", d_losses_fakes)
print_losses("Enc losses", e_losses)
print_losses("Gen losses", g_losses)
print_losses("Recon losses", recon_losses)
print_losses("Disc acc real", d_real_acc)
print_losses("Disc acc fake", d_fake_acc)
print("D mean acc", d_mean_acc)
print("D updated", d_updated)
running_losses["g_losses"][train_iter] = np.mean(g_losses)
running_losses["e_losses"][train_iter] = np.mean(e_losses)
running_losses["d_real_losses"][train_iter] = np.mean(d_losses_reals)
running_losses["d_fake_losses"][train_iter] = np.mean(d_losses_fakes)
running_losses["recon_losses"][train_iter] = np.mean(recon_losses)
running_losses["d_accuracy"][train_iter] = d_mean_acc
if train_iter + 1 == num_train_iter or \
(train_iter > 0 and train_iter % args.n_save == 0):
""" print_losses("Raw Disc", raw_d_losses)
print_losses("Raw Enc", raw_e_losses)
print_losses("Raw Gen", raw_g_losses)
"""
print("saving results and samples")
results = {
"disc_losses_reals": list(map(float, d_losses_reals)),
"disc_losses_fakes": list(map(float, d_losses_fakes)),
"enc_losses": list(map(float, e_losses)),
"gen_losses": list(map(float, g_losses)),
"timestamp": time.time()
}
res_path = os.path.join(args.out_dir,
"results_%i.json" % train_iter)
with open(res_path, 'w') as fp:
json.dump(results, fp)
if args.save_samples:
for zi, gen_sampler in enumerate(dcgan.gen_samplers):
sampled_imgs = []
for _ in range(10):
z_sampler = np.random.uniform(-1,
1,
size=(args.batch_size,
args.z_dim))
img = sess.run(gen_sampler,
feed_dict={dcgan.z_sampler: z_sampler})
sampled_imgs.append(img)
sampled_imgs = np.concatenate(sampled_imgs)
print_images(sampled_imgs,
"B_DCGAN_g%i" % zi,
train_iter,
directory=args.out_dir)
#print_images(
# image_batch, "RAW", train_iter, directory=args.out_dir)
evaluate_recon(sess, dcgan, args, dataset, train_iter)
if args.evaluate_latent:
all_latent_encodings = evaluate_latent(sess, dcgan, args,
dataset)
for ei, latent_encodings in enumerate(all_latent_encodings):
for r in range(1):
filename = "latent_encodings_e%d_r%d_%d.png" \
% (ei, r, train_iter)
plot_latent_encodings(latent_encodings,
savename=os.path.join(
args.out_dir, filename))
save_path = saver.save(sess, os.path.join(args.out_dir, "model.ckpt"))
print("Model saved to %s" % save_path)
losses_file = os.path.join(args.out_dir, "running_losses.npz")
np.savez(losses_file, **running_losses)
print("Saved running losses to", losses_file)
plot_losses(running_losses,
savename=os.path.join(args.out_dir, "losses_plot.png"))
results = evaluate_classification(sess, dcgan, args, dataset)
with open(os.path.join(args.out_dir, "classification.json"), "w") as fp:
json.dump(results, fp)
print("done")
