def __init__(self, num_epochs, keep_prob):
self.num_epochs = num_epochs
self.keep_prob = keep_prob
self.train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data()
map_test_labels = {}
map_labels = defaultdict(list)
for i in range(100):
item = test_labels[i]
map_labels[get_label(item)].append(i)
self.n_samples = train_size
self.x_hat = tf.placeholder(
tf.float32, shape=[None, dim_img], name='input_img')
self.x = tf.placeholder(
tf.float32, shape=[None, dim_img], name='target_img')
# self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')
z_in = tf.placeholder(
tf.float32, shape=[None, dim_z], name='latent_variable')
self.y, self.z, self.loss, self.neg_marginal_likelihood, self.KL_divergence = vae.autoencoder(
self.x_hat, self.x, dim_img, dim_z, n_hidden, self.keep_prob)
self.train_op = tf.train.AdamOptimizer(learn_rate).minimize(self.loss)
self.PRR = plot_utils.Plot_Reproduce_Performance(
RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, IMAGE_SIZE, IMAGE_SIZE, PRR_resize_factor)
self.x_PRR = test_data[0:self.PRR.n_tot_imgs, :]
x_PRR_img = self.x_PRR.reshape(
self.PRR.n_tot_imgs, IMAGE_SIZE, IMAGE_SIZE)
self.PRR.save_images(x_PRR_img, name='input.jpg')
self.x_PRR = self.x_PRR * np.random.randint(2, size=self.x_PRR.shape)
self.x_PRR += np.random.randint(2, size=self.x_PRR.shape)
x_PRR_img = self.x_PRR.reshape(self.PRR.n_tot_imgs, IMAGE_SIZE, IMAGE_SIZE)
self.PRR.save_images(x_PRR_img, name='input_noise.jpg')
# train
self.total_batch = int(self.n_samples / batch_size)
def main(args):
""" parameters """
RESULTS_DIR = ss.path.DATADIR + "vae/" + args.results_path
# network architecture
ADD_NOISE = args.add_noise
n_hidden = args.n_hidden
dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image
dim_z = args.dim_z
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
# Plot
PRR = args.PRR # Plot Reproduce Result
PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas
PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas
PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas
PMLR = args.PMLR # Plot Manifold Learning Result
PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas
PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas
PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas
PMLR_z_range = args.PMLR_z_range # range for random latent vector
PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space
""" prepare MNIST data """
train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data(
)
n_samples = train_size
""" build graph """
# input placeholders
# In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x
x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img')
# dropout
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# input for PMLR
z_in = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='latent_variable')
# network architecture
y, z, loss, neg_marginal_likelihood, KL_divergence = vae.autoencoder(
x_hat, x, dim_img, dim_z, n_hidden, keep_prob)
# optimization
train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss)
""" training """
# Plot for reproduce performance
if PRR:
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x,
PRR_n_img_y,
IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST,
PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input.jpg')
if ADD_NOISE:
x_PRR = x_PRR * np.random.randint(2, size=x_PRR.shape)
x_PRR += np.random.randint(2, size=x_PRR.shape)
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input_noise.jpg')
# Plot for manifold learning result
if PMLR and dim_z == 2:
PMLR = plot_utils.Plot_Manifold_Learning_Result(
RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range)
x_PMLR = test_data[0:PMLR_n_samples, :]
id_PMLR = test_labels[0:PMLR_n_samples, :]
if ADD_NOISE:
x_PMLR = x_PMLR * np.random.randint(2, size=x_PMLR.shape)
x_PMLR += np.random.randint(2, size=x_PMLR.shape)
decoded = vae.decoder(z_in, dim_img, n_hidden)
# train
total_batch = int(n_samples / batch_size)
min_tot_loss = 1e99
with tf.Session() as sess:
sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9})
for epoch in range(n_epochs):
# Random shuffling
np.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS]
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (n_samples)
batch_xs_input = train_data_[offset:(offset + batch_size), :]
batch_xs_target = batch_xs_input
# add salt & pepper noise
if ADD_NOISE:
batch_xs_input = batch_xs_input * np.random.randint(
2, size=batch_xs_input.shape)
batch_xs_input += np.random.randint(
2, size=batch_xs_input.shape)
_, tot_loss, loss_likelihood, loss_divergence = sess.run(
(train_op, loss, neg_marginal_likelihood, KL_divergence),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
keep_prob: 0.9
})
# print cost every epoch
print(
"epoch %d: L_tot %03.2f L_likelihood %03.2f L_divergence %03.2f"
% (epoch, tot_loss, loss_likelihood, loss_divergence))
# if minimum loss is updated or final epoch, plot results
if min_tot_loss > tot_loss or epoch + 1 == n_epochs:
min_tot_loss = tot_loss
# Plot for reproduce performance
if PRR:
y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, keep_prob: 1})
y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(y_PRR_img,
name="/PRR_epoch_%02d" % (epoch) + ".jpg")
# Plot for manifold learning result
if PMLR and dim_z == 2:
y_PMLR = sess.run(decoded,
feed_dict={
z_in: PMLR.z,
keep_prob: 1
})
y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs,
IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PMLR.save_images(y_PMLR_img,
name="/PMLR_epoch_%02d" % (epoch) +
".jpg")
# plot distribution of labeled images
z_PMLR = sess.run(z,
feed_dict={
x_hat: x_PMLR,
keep_prob: 1
})
PMLR.save_scattered_image(z_PMLR,
id_PMLR,
name="/PMLR_map_epoch_%02d" %
(epoch) + ".jpg")
def main(args):
""" parameters """
RESULTS_DIR = args.results_path
n_hidden = args.n_hidden
dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image
dim_z = args.dim_z
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
# Plotting
PRR_n_img_x = 4 # number of images along x-axis in a canvas
PRR_n_img_y = 4 # number of images along y-axis in a canvas
PRR_resize_factor = 1.0 # resize factor for each image in a canvas
""" prepare MNIST data """
train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data()
n_samples = train_size
# input placeholders
# In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x
x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img')
labels = tf.placeholder(tf.float32, shape=[None, 10], name='target_label')
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# network architecture
y, z, loss, neg_marginal_likelihood, KL_divergence = cvae.autoencoder(x_hat, x, labels, dim_img, dim_z, n_hidden, keep_prob)
# optimization
train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss)
""" training """
# Plot for reproduce performance
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
label_PRR = test_labels[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input.jpg')
# train
total_batch = int(n_samples / batch_size)
min_tot_loss = 1e99
with tf.Session() as sess:
sess.run(tf.global_variables_initializer(), feed_dict={keep_prob : 0.9})
for epoch in range(n_epochs):
# Random shuffling
np.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS]
train_label_ = train_total_data[:,-mnist_data.NUM_LABELS:]
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (n_samples)
batch_xs_input = train_data_[offset:(offset + batch_size), :]
batch_xs_target = batch_xs_input
batch_xs_labels = train_label_[offset:(offset + batch_size), :]
_, tot_loss, loss_likelihood, loss_divergence = sess.run(
(train_op, loss, neg_marginal_likelihood, KL_divergence),
feed_dict={x_hat: batch_xs_input, x: batch_xs_target, labels:batch_xs_labels, keep_prob : 0.9})
print("epoch %d: L_tot %03.2f" %(epoch,tot_loss))
# if minimum loss is updated or final epoch, plot results
if min_tot_loss > tot_loss or epoch+1 == n_epochs:
min_tot_loss = tot_loss
# Plot for reproduce performance
#print('reach here !!!')
y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, labels:label_PRR,keep_prob : 1})
y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST)
PRR.save_images(y_PRR_img, name="/PRR_epoch_%02d" %(epoch) + ".jpg")
def main(args):
""" parameters """
RESULTS_DIR = args.results_path
# network architecture
n_hidden = args.n_hidden
dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image
dim_z = 2 # to visualize learned manifold
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
# Plot
PRR = args.PRR # Plot Reproduce Result
PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas
PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas
PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas
PMLR = args.PMLR # Plot Manifold Learning Result
PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas
PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas
PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas
PMLR_z_range = args.PMLR_z_range # range for random latent vector
PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space
""" prepare MNIST data """
train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data(
)
n_samples = train_size
""" build graph """
# input placeholders
# In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x
x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img')
x_id = tf.placeholder(tf.float32, shape=[None, 10], name='input_img_label')
# dropout
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# input for PMLR
z_in = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='latent_variable')
# samples drawn from prior distribution
z_sample = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='prior_sample')
z_id = tf.placeholder(tf.float32,
shape=[None, 10],
name='prior_sample_label')
# network architecture
y, z, neg_marginal_likelihood, D_loss, G_loss = aae.adversarial_autoencoder(
x_hat, x, x_id, z_sample, z_id, dim_img, dim_z, n_hidden, keep_prob)
# optimization
t_vars = tf.trainable_variables()
d_vars = [var for var in t_vars if "discriminator" in var.name]
g_vars = [var for var in t_vars if "MLP_encoder" in var.name]
ae_vars = [
var for var in t_vars if "MLP_encoder" or "MLP_decoder" in var.name
]
train_op_ae = tf.train.AdamOptimizer(learn_rate).minimize(
neg_marginal_likelihood, var_list=ae_vars)
train_op_d = tf.train.AdamOptimizer(learn_rate / 5).minimize(
D_loss, var_list=d_vars)
train_op_g = tf.train.AdamOptimizer(learn_rate).minimize(G_loss,
var_list=g_vars)
""" training """
# Plot for reproduce performance
if PRR:
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x,
PRR_n_img_y,
IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST,
PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input.jpg')
# Plot for manifold learning result
if PMLR and dim_z == 2:
PMLR = plot_utils.Plot_Manifold_Learning_Result(
RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range)
x_PMLR = test_data[0:PMLR_n_samples, :]
id_PMLR = test_labels[0:PMLR_n_samples, :]
decoded = aae.decoder(z_in, dim_img, n_hidden)
# train
total_batch = int(n_samples / batch_size)
min_tot_loss = 1e99
with tf.Session() as sess:
sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9})
for epoch in range(n_epochs):
# Random shuffling
np.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS]
train_label_ = train_total_data[:, -mnist_data.NUM_LABELS:]
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (n_samples)
batch_xs_input = train_data_[offset:(offset + batch_size), :]
batch_ids_input = train_label_[offset:(offset + batch_size), :]
batch_xs_target = batch_xs_input
# draw samples from prior distribution
if args.prior_type == 'mixGaussian':
z_id_ = np.random.randint(0, 10, size=[batch_size])
samples = prior.gaussian_mixture(batch_size,
dim_z,
label_indices=z_id_)
elif args.prior_type == 'swiss_roll':
z_id_ = np.random.randint(0, 10, size=[batch_size])
samples = prior.swiss_roll(batch_size,
dim_z,
label_indices=z_id_)
elif args.prior_type == 'normal':
samples, z_id_ = prior.gaussian(batch_size,
dim_z,
use_label_info=True)
else:
raise Exception("[!] There is no option for " +
args.prior_type)
z_id_one_hot_vector = np.zeros((batch_size, 10))
z_id_one_hot_vector[np.arange(batch_size), z_id_] = 1
# reconstruction loss
_, loss_likelihood = sess.run(
(train_op_ae, neg_marginal_likelihood),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
x_id: batch_ids_input,
z_sample: samples,
z_id: z_id_one_hot_vector,
keep_prob: 0.9
})
# discriminator loss
_, d_loss = sess.run(
(train_op_d, D_loss),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
x_id: batch_ids_input,
z_sample: samples,
z_id: z_id_one_hot_vector,
keep_prob: 0.9
})
# generator loss
for _ in range(2):
_, g_loss = sess.run(
(train_op_g, G_loss),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
x_id: batch_ids_input,
z_sample: samples,
z_id: z_id_one_hot_vector,
keep_prob: 0.9
})
tot_loss = loss_likelihood + d_loss + g_loss
# print cost every epoch
print(
"epoch %d: L_tot %03.2f L_likelihood %03.2f d_loss %03.2f g_loss %03.2f"
% (epoch, tot_loss, loss_likelihood, d_loss, g_loss))
# if minimum loss is updated or final epoch, plot results
if epoch % 2 == 0 or min_tot_loss > tot_loss or epoch + 1 == n_epochs:
min_tot_loss = tot_loss
# Plot for reproduce performance
if PRR:
y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, keep_prob: 1})
y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(y_PRR_img,
name="/PRR_epoch_%02d" % (epoch) + ".jpg")
# Plot for manifold learning result
if PMLR and dim_z == 2:
y_PMLR = sess.run(decoded,
feed_dict={
z_in: PMLR.z,
keep_prob: 1
})
y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs,
IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PMLR.save_images(y_PMLR_img,
name="/PMLR_epoch_%02d" % (epoch) +
".jpg")
# plot distribution of labeled images
z_PMLR = sess.run(z,
feed_dict={
x_hat: x_PMLR,
keep_prob: 1
})
PMLR.save_scattered_image(z_PMLR,
id_PMLR,
name="/PMLR_map_epoch_%02d" %
(epoch) + ".jpg")
def main(args):
np.random.seed(1337)
""" parameters """
RESULTS_DIR = args.results_path
# network architecture
n_hidden = args.n_hidden
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
# Plot
PRR = args.PRR # Plot Reproduce Result
PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas
PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas
PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas
PMLR = args.PMLR # Plot Manifold Learning Result
PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas
PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas
PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas
PMLR_z_range = args.PMLR_z_range # range for random latent vector
PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space
""" prepare MNIST data """
'''
esense_files = [
"AAU_livingLab4_202481591532165_1541682359",
"fabio_1-202481588431654_1541691060",
"alemino_ZRH_202481601716927_1541691041",
"IMDEA_wideband_202481598624002_1541682492"
]
b
esense_folder = "./datadumps/esense_data_jan2019/"
#train_data, train_labels, test_data, test_labels, bw_labels, pos_labels = spec_data.gendata()
for ei,efile in enumerate(esense_files):
print efile
if ei==0:
train_data, train_labels,_ = esense_seqload.gendata(esense_folder+efile)
else:
dtrain_data, dtrain_labels,_ = esense_seqload.gendata(esense_folder+efile)
train_data = np.vstack((train_data,dtrain_data))
train_labels = np.vstack((train_labels,dtrain_labels))
'''
#train_data, train_labels, _,_,_,_,_ = synthetic_data.gendata()
train_data, train_labels, _, _, _ = hackrf_data.gendata(
"./datadumps/sample_hackrf_data.csv")
#train_data, train_labels = rawdata.gendata()
#Split the data
train_data, train_labels = shuffle_in_unison_inplace(
train_data, train_labels)
splitval = int(train_data.shape[0] * 0.5)
test_data = train_data[:splitval]
test_labels = train_labels[:splitval]
train_data = train_data[splitval:]
train_labels = train_labels[splitval:]
#Semsup splitting
splitval = int(train_data.shape[0] * 0.2)
train_data_sup = train_data[:splitval]
train_data = train_data[splitval:]
train_labels_sup = train_labels[:splitval]
train_labels = train_labels[splitval:]
n_samples = train_data.shape[0]
tsamples = train_data.shape[1]
fsamples = train_data.shape[2]
dim_img = [tsamples, fsamples]
nlabels = train_labels.shape[1]
print(nlabels)
encoder = "CNN"
#encoder="LSTM"
dim_z = args.dimz # to visualize learned manifold
enable_sel = False
""" build graph """
# input placeholders
x_hat = tf.placeholder(tf.float32,
shape=[None, tsamples, fsamples],
name='input_img')
x = tf.placeholder(tf.float32,
shape=[None, tsamples, fsamples],
name='target_img')
x_id = tf.placeholder(tf.float32,
shape=[None, nlabels],
name='input_img_label')
# dropout
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
# input for PMLR
z_in = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='latent_variable')
# samples drawn from prior distribution
z_sample = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='prior_sample')
cat_sample = tf.placeholder(tf.float32,
shape=[None, nlabels],
name='prior_sample_label')
# network architecture
#y, z, neg_marginal_likelihood, D_loss, G_loss = aae.adversarial_autoencoder(x_hat, x, x_id, z_sample, z_id, dim_img,
# dim_z, n_hidden, keep_prob)
y, z, neg_marginal_likelihood, D_loss, G_loss, cat_gen_loss, cat = spec_aae.adversarial_autoencoder_semsup_cat_nodimred(
x_hat,
x,
x_id,
z_sample,
cat_sample,
dim_img,
dim_z,
n_hidden,
keep_prob,
nlabels=nlabels,
vdim=2)
# optimization
t_vars = tf.trainable_variables()
d_vars = [
var for var in t_vars
if "discriminator" or "discriminator_cat" in var.name
]
g_vars = [var for var in t_vars if encoder + "_encoder_cat" in var.name]
ae_vars = [
var for var in t_vars
if encoder + "_encoder_cat" or "CNN_decoder" in var.name
]
train_op_ae = tf.train.AdamOptimizer(learn_rate).minimize(
neg_marginal_likelihood, var_list=ae_vars)
train_op_d = tf.train.AdamOptimizer(learn_rate / 2.0).minimize(
D_loss, var_list=d_vars)
train_op_g = tf.train.AdamOptimizer(learn_rate).minimize(G_loss,
var_list=g_vars)
train_op_cat = tf.train.AdamOptimizer(learn_rate).minimize(cat_gen_loss,
var_list=g_vars)
""" training """
# Plot for reproduce performance
if PRR:
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x,
PRR_n_img_y, tsamples,
fsamples,
PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, tsamples, fsamples)
PRR.save_images(x_PRR_img, name='input.jpg')
# Plot for manifold learning result
if PMLR and dim_z == 2:
PMLR = plot_utils.Plot_Manifold_Learning_Result(
RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, tsamples, fsamples,
PMLR_resize_factor, PMLR_z_range)
x_PMLR = test_data[0:PMLR_n_samples, :]
id_PMLR = test_labels[0:PMLR_n_samples, :]
decoded = spec_aae.decoder(z_in, dim_img, n_hidden)
else:
x_PMLR = test_data[0:PMLR_n_samples, :]
id_PMLR = test_labels[0:PMLR_n_samples, :]
z_in = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='latent_variable')
# train
total_batch = int(n_samples / batch_size)
min_tot_loss = 1e99
prev_loss = 1e99
saver = tf.train.Saver()
with tf.Session() as sess:
sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9})
for epoch in range(n_epochs):
# Random shuffling
train_data_, train_label_ = shuffle_in_unison_inplace(
train_data, train_labels)
train_data_sup_, train_labels_sup_ = shuffle_in_unison_inplace(
train_data_sup, train_labels_sup)
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (n_samples)
offset_sup = (i * batch_size) % (train_data_sup.shape[0])
batch_xs_input = train_data_[offset:(offset + batch_size), :]
batch_ids_input = train_label_[offset:(offset + batch_size), :]
batch_xs_sup_input = train_data_sup_[offset_sup:(
offset_sup + batch_size), :]
batch_ids_sup_input = train_labels_sup_[offset_sup:(
offset_sup + batch_size), :]
batch_xs_target = batch_xs_input
batch_xs_sup_target = batch_xs_sup_input
# draw samples from prior distribution
if dim_z > 2:
if enable_sel:
if args.prior_type == 'mixGaussian':
z_id_ = np.random.randint(0,
nlabels,
size=[batch_size])
samples = np.zeros((batch_size, dim_z))
for el in range(dim_z / 2):
samples_ = prior.gaussian_mixture(
batch_size,
2,
n_labels=nlabels,
label_indices=z_id_,
y_var=(1.0 / nlabels))
samples[:, el * 2:(el + 1) * 2] = samples_
elif args.prior_type == 'swiss_roll':
z_id_ = np.random.randint(0,
nlabels,
size=[batch_size])
samples = np.zeros((batch_size, dim_z))
for el in range(dim_z / 2):
samples_ = prior.swiss_roll(
batch_size, 2, label_indices=z_id_)
samples[:, el * 2:(el + 1) * 2] = samples_
elif args.prior_type == 'normal':
samples, z_id_ = prior.gaussian(
batch_size,
dim_z,
n_labels=nlabels,
use_label_info=True)
else:
raise Exception("[!] There is no option for " +
args.prior_type)
else:
z_id_ = np.random.randint(0,
nlabels,
size=[batch_size])
samples = np.random.normal(
0.0, 1, (batch_size, dim_z)).astype(np.float32)
else:
if args.prior_type == 'mixGaussian':
z_id_ = np.random.randint(0,
nlabels,
size=[batch_size])
samples = prior.gaussian_mixture(batch_size,
dim_z,
n_labels=nlabels,
label_indices=z_id_,
y_var=(1.0 / nlabels))
elif args.prior_type == 'swiss_roll':
z_id_ = np.random.randint(0,
nlabels,
size=[batch_size])
samples = prior.swiss_roll(batch_size,
dim_z,
label_indices=z_id_)
elif args.prior_type == 'normal':
samples, z_id_ = prior.gaussian(batch_size,
dim_z,
n_labels=nlabels,
use_label_info=True)
else:
raise Exception("[!] There is no option for " +
args.prior_type)
z_id_one_hot_vector = np.zeros((batch_size, nlabels))
z_id_one_hot_vector[np.arange(batch_size), z_id_] = 1
# reconstruction loss
_, loss_likelihood0 = sess.run(
(train_op_ae, neg_marginal_likelihood),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
z_sample: samples,
cat_sample: z_id_one_hot_vector,
keep_prob: 0.9
})
_, loss_likelihood1 = sess.run(
(train_op_ae, neg_marginal_likelihood),
feed_dict={
x_hat: batch_xs_sup_input,
x: batch_xs_sup_target,
z_sample: samples,
cat_sample: batch_ids_sup_input,
keep_prob: 0.9
})
loss_likelihood = loss_likelihood0 + loss_likelihood1
# discriminator loss
_, d_loss = sess.run(
(train_op_d, D_loss),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
z_sample: samples,
cat_sample: z_id_one_hot_vector,
keep_prob: 0.9
})
# generator loss
for _ in range(2):
_, g_loss = sess.run(
(train_op_g, G_loss),
feed_dict={
x_hat: batch_xs_input,
x: batch_xs_target,
z_sample: samples,
cat_sample: z_id_one_hot_vector,
keep_prob: 0.9
})
# supervised phase
_, cat_loss = sess.run(
(train_op_cat, cat_gen_loss),
feed_dict={
x_hat: batch_xs_sup_input,
x: batch_xs_sup_target,
x_id: batch_ids_sup_input,
keep_prob: 0.9
})
tot_loss = loss_likelihood + d_loss + g_loss + cat_loss
# print cost every epoch
print(
"epoch %d: L_tot %03.2f L_likelihood %03.4f d_loss %03.2f g_loss %03.2f "
% (epoch, tot_loss, loss_likelihood, d_loss, g_loss))
#for v in sess.graph.get_operations():
# print(v.name)
# if minimum loss is updated or final epoch, plot results
if epoch % 2 == 0 or min_tot_loss > tot_loss or epoch + 1 == n_epochs:
min_tot_loss = tot_loss
# Plot for reproduce performance
if PRR:
y_PRR = sess.run(y, feed_dict={x_hat: x_PRR, keep_prob: 1})
save_subimages([x_PRR[:10], y_PRR[:10]],
"./results/Reco_%02d" % (epoch))
#y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, tsamples, fsamples)
#PRR.save_images(y_PRR_img, name="/PRR_epoch_%02d" %(epoch) + ".jpg")
# Plot for manifold learning result
if PMLR and dim_z == 2:
y_PMLR = sess.run(decoded,
feed_dict={
z_in: PMLR.z,
keep_prob: 1
})
y_PMLR_img = y_PMLR.reshape(PMLR_n_img_x, PMLR_n_img_x,
tsamples, fsamples)
save_subimages(y_PMLR_img, "./results/Mani_%02d" % (epoch))
#y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, fsamples, tsamples)
#PMLR.save_images(y_PMLR_img, name="/PMLR_epoch_%02d" % (epoch) + ".jpg")
# plot distribution of labeled images
z_PMLR = sess.run(z,
feed_dict={
x_hat: x_PMLR,
keep_prob: 1
})
PMLR.save_scattered_image(z_PMLR,
id_PMLR,
name="/PMLR_map_epoch_%02d" %
(epoch) + ".jpg",
N=nlabels)
else:
retcat, test_cat_loss, test_ll = sess.run(
(cat, cat_gen_loss, neg_marginal_likelihood),
feed_dict={
x_hat: x_PMLR,
x_id: id_PMLR,
x: x_PMLR,
keep_prob: 1
})
print(
"Accuracy: ", 100.0 *
np.sum(np.argmax(retcat, 1) == np.argmax(id_PMLR, 1)) /
retcat.shape[0], test_cat_loss, test_ll)
save_loss = test_cat_loss + test_ll
if prev_loss > save_loss and (epoch % 100
== 0): # and epoch!=0:
prev_loss = save_loss
#save_graph(sess,"./savedmodels/","saved_checkpoint","checkpoint_state","input_graph.pb","output_graph.pb",encoder+"_encoder_cat/zout/BiasAdd,"+encoder+"_encoder_cat/catout/Softmax,CNN_decoder/reshaped/Reshape,discriminator_cat_1/add_2,discriminator_1/add_2")
save_path = saver.save(
sess, "./savedmodels_allsensors/allsensors.ckpt")
tf.train.write_graph(sess.graph_def,
"./savedmodels_allsensors/",
"allsensors.pb",
as_text=False)
def main(args):
# torch.manual_seed(222)
# torch.cuda.manual_seed_all(222)
# np.random.seed(222)
device = torch.device('cuda')
RESULTS_DIR = args.results_path
ADD_NOISE = args.add_noise
n_hidden = args.n_hidden
dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image
dim_z = args.dim_z
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
# Plot
PRR = args.PRR # Plot Reproduce Result
PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas
PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas
PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas
PMLR = args.PMLR # Plot Manifold Learning Result
PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas
PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas
PMLR_resize_factor = args.PMLR_resize_factor # resize factor for each image in a canvas
PMLR_z_range = args.PMLR_z_range # range for random latent vector
PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space
""" prepare MNIST data """
train_total_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data(
)
n_samples = train_size
""" create network """
keep_prob = 0.99
encoder = vae.Encoder(dim_img, n_hidden, dim_z, keep_prob).to(device)
decoder = vae.Decoder(dim_z, n_hidden, dim_img, keep_prob).to(device)
# + operator will return but .extend is inplace no return.
optimizer = torch.optim.Adam(list(encoder.parameters()) +
list(decoder.parameters()),
lr=learn_rate)
# vae.init_weights(encoder, decoder)
""" training """
# Plot for reproduce performance
if PRR:
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x,
PRR_n_img_y,
IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST,
PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input.jpg')
print('saved:', 'input.jpg')
if ADD_NOISE:
x_PRR = x_PRR * np.random.randint(2, size=x_PRR.shape)
x_PRR += np.random.randint(2, size=x_PRR.shape)
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input_noise.jpg')
print('saved:', 'input_noise.jpg')
x_PRR = torch.from_numpy(x_PRR).float().to(device)
# Plot for manifold learning result
if PMLR and dim_z == 2:
PMLR = plot_utils.Plot_Manifold_Learning_Result(
RESULTS_DIR, PMLR_n_img_x, PMLR_n_img_y, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST, PMLR_resize_factor, PMLR_z_range)
x_PMLR = test_data[0:PMLR_n_samples, :]
id_PMLR = test_labels[0:PMLR_n_samples, :]
if ADD_NOISE:
x_PMLR = x_PMLR * np.random.randint(2, size=x_PMLR.shape)
x_PMLR += np.random.randint(2, size=x_PMLR.shape)
z_ = torch.from_numpy(PMLR.z).float().to(device)
x_PMLR = torch.from_numpy(x_PMLR).float().to(device)
# train
total_batch = int(n_samples / batch_size)
min_tot_loss = np.inf
for epoch in range(n_epochs):
# Random shuffling
np.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS]
# Loop over all batches
encoder.train()
decoder.train()
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (n_samples)
batch_xs_input = train_data_[offset:(offset + batch_size), :]
batch_xs_target = batch_xs_input
# add salt & pepper noise
if ADD_NOISE:
batch_xs_input = batch_xs_input * np.random.randint(
2, size=batch_xs_input.shape)
batch_xs_input += np.random.randint(2,
size=batch_xs_input.shape)
batch_xs_input, batch_xs_target = torch.from_numpy(batch_xs_input).float().to(device), \
torch.from_numpy(batch_xs_target).float().to(device)
assert not torch.isnan(batch_xs_input).any()
assert not torch.isnan(batch_xs_target).any()
y, z, tot_loss, loss_likelihood, loss_divergence = \
vae.get_loss(encoder, decoder, batch_xs_input, batch_xs_target)
optimizer.zero_grad()
tot_loss.backward()
optimizer.step()
# print cost every epoch
print(
"epoch %d: L_tot %03.2f L_likelihood %03.2f L_divergence %03.2f" %
(epoch, tot_loss.item(), loss_likelihood.item(),
loss_divergence.item()))
encoder.eval()
decoder.eval()
# if minimum loss is updated or final epoch, plot results
if min_tot_loss > tot_loss.item() or epoch + 1 == n_epochs:
min_tot_loss = tot_loss.item()
# Plot for reproduce performance
if PRR:
y_PRR = vae.get_ae(encoder, decoder, x_PRR)
y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PRR.save_images(y_PRR_img.detach().cpu().numpy(),
name="/PRR_epoch_%02d" % (epoch) + ".jpg")
print('saved:', "/PRR_epoch_%02d" % (epoch) + ".jpg")
# Plot for manifold learning result
if PMLR and dim_z == 2:
y_PMLR = decoder(z_)
y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
PMLR.save_images(y_PMLR_img.detach().cpu().numpy(),
name="/PMLR_epoch_%02d" % (epoch) + ".jpg")
print('saved:', "/PMLR_epoch_%02d" % (epoch) + ".jpg")
# plot distribution of labeled images
z_PMLR = vae.get_z(encoder, x_PMLR)
PMLR.save_scattered_image(z_PMLR.detach().cpu().numpy(),
id_PMLR,
name="/PMLR_map_epoch_%02d" %
(epoch) + ".jpg")
print('saved:', "/PMLR_map_epoch_%02d" % (epoch) + ".jpg")
def main(args):
""" parameters """
RESULTS_DIR = args.results_path
# network architecture
ADD_NOISE = args.add_noise
n_hidden = args.n_hidden
dim_img = IMAGE_SIZE_MNIST**2 # number of pixels for a MNIST image
dim_z = args.dim_z
# train
n_epochs = args.num_epochs
batch_size = args.batch_size
learn_rate = args.learn_rate
# Plot
PRR = args.PRR # Plot Reproduce Result
PRR_n_img_x = args.PRR_n_img_x # number of images along x-axis in a canvas
PRR_n_img_y = args.PRR_n_img_y # number of images along y-axis in a canvas
PRR_resize_factor = args.PRR_resize_factor # resize factor for each image in a canvas
PMLR = args.PMLR # Plot Manifold Learning Result
PMLR_n_img_x = args.PMLR_n_img_x # number of images along x-axis in a canvas
PMLR_n_img_y = args.PMLR_n_img_y # number of images along y-axis in a canvas
PMLR_resize_factor = args.PMLR_resize_factor# resize factor for each image in a canvas
PMLR_z_range = args.PMLR_z_range # range for random latent vector
PMLR_n_samples = args.PMLR_n_samples # number of labeled samples to plot a map from input data space to the latent space
""" prepare MNIST data """
train_total_data, train_size, test_data, test_labels = mnist_data.prepare_MNIST_data()
n_samples = train_size
para_lamda=10.0
clipping_parameter = 0.01
n_critic = 5
#train_data = train_total_data[:, :-mnist_data.NUM_LABELS]
""" build graph """
# input placeholders
# In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x
#x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img')
batchsize=tf.placeholder(tf.float32, name='batchsize')
# input for PMLR
z = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable')
cond_info= tf.placeholder(tf.float32, shape=[None, 12], name='cond_info')
encoder_output = CNNVae.gaussian_CNN_encoder(x, cond_info, dim_z)
decoder_output = CNNVae.gaussian_CNN_decoder(encoder_output,cond_info)
with tf.variable_scope('Discriminator') as scope:
D_real = CNNVae.discriminator(z,n_hidden)
scope.reuse_variables()
D_fake = CNNVae.discriminator(encoder_output,n_hidden)
alpha = tf.random_uniform(
shape=[batch_size, 1],
minval=0.,
maxval=1.
)
differences = encoder_output - z # may cause problem!!!
interpolates = z + (alpha * differences)
# gradients = tf.gradients(Discriminator(interpolates), [interpolates])[0]
gradients = tf.gradients(CNNVae.discriminator(interpolates, n_hidden), [interpolates])[0]
slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1]))
gradient_penalty = tf.reduce_mean((slopes - 1.) ** 2)
ddx = 10.0 * gradient_penalty
# ddx = gradient_penalty(z, encoder_output, CNNVae.discriminator)
# ddx = ddx*10.0
with tf.name_scope('Loss'):
#marginal_likelihood = tf.reduce_sum(3.14/4.0*tf.exp(2.0*(x-decoder_output))-2.0*(x-decoder_output), 1)
#loss_reconstr = tf.reduce_mean(marginal_likelihood)
loss_reconstr = tf.reduce_mean(3.14/4.0*tf.exp(2.0*(x-decoder_output))-2.0*(x-decoder_output))
# Adversarial loss to approx. Q(z|X)
with tf.name_scope('Discriminator_loss'):
#loss_discriminator = -para_lamda*(tf.reduce_mean(tf.log(D_real)) + tf.reduce_mean(tf.log(1.0-D_fake)))
loss_discriminator = 1.0*(tf.reduce_mean(D_fake) - tf.reduce_mean(D_real)+ddx)
with tf.name_scope('Encoder_loss'):
#loss_encoder = -para_lamda* tf.reduce_mean(tf.log(D_fake))
loss_encoder = -(1.0)*tf.reduce_mean(D_fake)
vars = tf.trainable_variables()
enc_params = [v for v in vars if 'g_encoder_' in v.name]
dec_params = [v for v in vars if 'g_decoder_' in v.name]
dis_params = [v for v in vars if 'g_dis_' in v.name]
dis_weights = [w for w in dis_params if 'weight' in w.name]
with tf.variable_scope('Discriminator_Accuracy'):
accuracy_real = tf.reduce_mean(tf.cast(tf.greater_equal(D_real, 0.5), tf.float16))
accuracy_fake = tf.reduce_mean(tf.cast(tf.less(D_fake, 0.5), tf.float16))
accuracy_tot = (accuracy_real + accuracy_fake) / 2
#accuracy_tot = tf.reduce_mean(D_real) - tf.reduce_mean(D_fake)
#clipped_weights = clip_weights(dis_weights, clipping_parameter, 'clip_weights')
CLIP = [-0.04, 0.04]
clipped_weights = [var.assign(tf.clip_by_value(var, CLIP[0], CLIP[1])) for var in dis_weights]
with tf.name_scope('Optimizer'):
train_op_AE = tf.train.AdamOptimizer(learning_rate=learn_rate,beta1=0.,beta2=0.9).minimize(loss_reconstr+para_lamda*loss_encoder,var_list=[dec_params,enc_params])
train_op_Dis = tf.train.AdamOptimizer(learning_rate=learn_rate,beta1=0.,beta2=0.9).minimize(para_lamda*loss_discriminator,var_list=[dis_params])
test_smaple_size=12800
test_batch_size=128
z_test = tf.placeholder(tf.float32, shape=[test_batch_size, dim_z])
test_cond_info = tf.placeholder(tf.float32, shape=[test_batch_size, 12], name='test_cond_info')
test_op = CNNVae.CNN_decoder(z_test, test_cond_info)
mu_test = tf.zeros([test_smaple_size, dim_z], dtype=tf.float32)
test_sample = mu_test + tf.random_normal(tf.shape(mu_test), 0, 1, dtype=tf.float32)
test_rand = np.random.randint(0, 10,size=[test_smaple_size,1]) #[0,10)
test_info=num_to_one_hot(test_rand)
test_angle=np.random.randint(0, 360,size=[test_smaple_size,1]) #[0,360)
sin_angle=np.sin(test_angle/180.0*np.pi)
cos_angle=np.cos(test_angle/180.0*np.pi)
test_info = np.concatenate((test_info, sin_angle), axis=1)
test_info = np.concatenate((test_info, cos_angle), axis=1)
savename = "./label" + ".mat"
sio.savemat(savename, {'label': test_rand})
savename = "./angle" + ".mat"
sio.savemat(savename, {'angle': test_angle})
""" training """
loss_array = np.zeros(shape=[n_epochs, 1], dtype=np.float32)
epoch_array = np.zeros(shape=[n_epochs, 1], dtype=np.uint)
# Plot for reproduce performance
if PRR:
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x, PRR_n_img_y, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST, PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
x_PRR_info = test_labels[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST)
PRR.save_images(x_PRR_img, name='input.jpg')
sio.savemat('testimage.mat', {'testimage': x_PRR})
# train
total_batch = int(n_samples / batch_size)
min_tot_loss = 1e99
min_tot_mar_loss=1e99
#force using cpu instead of gpu 0:cpu 1:gpu
config = tf.ConfigProto(device_count={'GPU':1})
with tf.Session(config=config) as sess:
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
# to visualize using TensorBoard
writer = tf.summary.FileWriter('./graphs', sess.graph)
ckpt = tf.train.get_checkpoint_state(os.path.dirname('./checkpoints/'))
# if that checkpoint exists, restore from checkpoint
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
for epoch in range(n_epochs):
total_loss_likelihood = 0.0
total_loss_divergence = 0.0
total_loss_dis =0.0
# Random shuffling
np.random.shuffle(train_total_data)
#train_data_ = train_total_data[:, :-mnist_data.NUM_LABELS]
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (n_samples)
batch_xs_input = train_total_data[offset:(offset + batch_size), :-12]
batch_cond_info = train_total_data[offset:(offset + batch_size), -12:]
# update autoencoder parameters
#z0 = np.random.randn(128, dim_z)
#_, loss_divergence ,enc_out= sess.run((train_op_Enc, loss_encoder,encoder_output),feed_dict={x: batch_xs_input, cond_info: batch_cond_info})
_,loss_likelihood,loss_divergence= sess.run((train_op_AE,loss_reconstr,loss_encoder), feed_dict={ x: batch_xs_input, cond_info:batch_cond_info,batchsize:batch_xs_input.shape[0]})
# update discriminator
for _ in range(n_critic):
z0 = np.random.normal(loc=0., scale=1, size=(batch_size, dim_z))
_, loss_dis = sess.run((train_op_Dis, loss_discriminator),
feed_dict={ x: batch_xs_input, cond_info: batch_cond_info, z: z0})
# _ = sess.run(clipped_weights)
total_loss_likelihood = total_loss_likelihood + loss_likelihood
total_loss_divergence = total_loss_divergence + loss_divergence
total_loss_dis = total_loss_dis + loss_dis
total_loss_likelihood = total_loss_likelihood / total_batch
total_loss_divergence = total_loss_divergence / total_batch
total_loss_dis = total_loss_dis / total_batch
tot_loss = total_loss_divergence + total_loss_likelihood
epoch_array[epoch] = epoch
loss_array[epoch] = total_loss_likelihood
# print cost every epoch
print("epoch %d: L_likelihood %03.3f L_divergence %03.3f L_dis %03.3f" % (epoch, total_loss_likelihood*4096, total_loss_divergence,total_loss_dis))
# if minimum loss is updated or final epoch, plot results
#if min_tot_loss > tot_loss or min_tot_mar_loss > total_loss_likelihood or epoch+1 == n_epochs:
if epoch %10==0:
saver.save(sess, './checkpoints/checkpoint', epoch)
min_tot_loss = tot_loss
min_tot_mar_loss = total_loss_likelihood
# Plot for reproduce performance
if PRR:
#z_PRR = sess.run(encoder_output,feed_dict={x: x_PRR, cond_info: x_PRR_info})
y_PRR = sess.run(decoder_output, feed_dict={x: x_PRR, cond_info:x_PRR_info})
y_PRR_img = y_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST)
t_z = np.random.normal(loc=0., scale=1, size=(batch_size, dim_z))
t_rand = np.random.randint(0, 10, size=[test_batch_size, 1]) # [0,10)
t_info = num_to_one_hot(t_rand)
#t_angle = np.random.randint(0, 360, size=[test_batch_size, 1]) # [0,360)
t_angle = np.random.uniform(size=[test_batch_size, 1])*360 # [0,360)
sin_angle = np.sin(t_angle / 180.0 * np.pi)
cos_angle = np.cos(t_angle / 180.0 * np.pi)
t_info = np.concatenate((t_info, sin_angle), axis=1)
t_info = np.concatenate((t_info, cos_angle), axis=1)
x_test = sess.run(test_op, feed_dict={z_test: t_z, test_cond_info: t_info})
x_test= x_test.reshape(test_batch_size, IMAGE_SIZE_MNIST,IMAGE_SIZE_MNIST)
if epoch%10==0 :
PRR.save_images(y_PRR_img, name="/PRR_epoch_%02d" % (epoch) + ".jpg")
PRR.save_images(x_test, name="/GER_epoch_%02d" % (epoch) + ".jpg")
if PRR and save_result:
test_image=np.zeros([test_smaple_size,IMAGE_SIZE_MNIST,IMAGE_SIZE_MNIST],dtype=np.float32)
test_sample=sess.run(test_sample)
test_batch = int(test_smaple_size/test_batch_size)
for i in range(test_batch):
# Compute the offset of the current minibatch in the data.
offset = i * test_batch_size
test_input = test_sample[offset:(offset + test_batch_size), :]
test_input_info = test_info[offset:(offset + test_batch_size), :]
x_test=sess.run(test_op,feed_dict={z_test:test_input,test_cond_info:test_input_info})
test_image[offset:(offset + test_batch_size),:,:] = x_test.reshape(test_batch_size, IMAGE_SIZE_MNIST, IMAGE_SIZE_MNIST)
PRR.save_images(test_image[0:128,:,:], name="/PRR_test" + ".jpg")
savename="./fakeimdb_loss_%03.2f" % (tot_loss) + ".mat"
sio.savemat(savename,{'fakeimdb':test_image})
# print('test_labels', test_labels[90])
n_samples = train_size
x_hat = tf.placeholder(tf.float32, shape=[None, dim_img], name='input_img')
x = tf.placeholder(tf.float32, shape=[None, dim_img], name='target_img')
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
z_in = tf.placeholder(tf.float32,
shape=[None, dim_z],
name='latent_variable')
y, z, loss, neg_marginal_likelihood, KL_divergence = vae.autoencoder(
x_hat, x, dim_img, dim_z, n_hidden, keep_prob)
train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss)
PRR = plot_utils.Plot_Reproduce_Performance(RESULTS_DIR, PRR_n_img_x,
PRR_n_img_y, IMAGE_SIZE,
IMAGE_SIZE, PRR_resize_factor)
x_PRR = test_data[0:PRR.n_tot_imgs, :]
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE, IMAGE_SIZE)
PRR.save_images(x_PRR_img, name='input.jpg')
x_PRR = x_PRR * np.random.randint(2, size=x_PRR.shape)
x_PRR += np.random.randint(2, size=x_PRR.shape)
x_PRR_img = x_PRR.reshape(PRR.n_tot_imgs, IMAGE_SIZE, IMAGE_SIZE)
PRR.save_images(x_PRR_img, name='input_noise.jpg')
# train
total_batch = int(n_samples / batch_size)
def main(args):
device = torch.device('cuda: 0' if torch.cuda.is_available() else 'cpu')
'''prepare cifar 10 data '''
train_data, train_label, val_data, val_label, test_data, test_labels = cifar10_data.prepare_cifar_10_data()
n_train_samples = train_data.shape[0]
n_samples = n_train_samples #only train 2000 images as test
#n_samples = 2000
n_val_samples = val_data.shape[0]
n_test_samples = test_data.shape[0]
image_size = 32
input_dim = 3
output_dim = 3
train_data = train_data.reshape(n_train_samples, input_dim, image_size, image_size)
train_data = train_data[:n_samples, :, :, :]
val_data = val_data.reshape(n_val_samples, input_dim, image_size, image_size)
test_data = test_data.reshape(n_test_samples, input_dim, image_size, image_size)
""" create network """
encoder = vae2.Encoder(input_dim, args.zdim, args.use_batch_norm).to(device)
decoder = vae2.Decoder(args.zdim, output_dim, args.use_batch_norm).to(device)
if args.optimizer == 'Adam':
optimizer = torch.optim.Adam(list(encoder.parameters()) + list(decoder.parameters()), lr=args.learn_rate)
elif args.optimizer == 'SGD':
optimizer = torch.optim.SGD(list(encoder.parameters()) + list(decoder.parameters()), lr=args.learn_rate, momentum=args.momentum)
else:
print("wrong optimizer")
return
# init weights
if args.seed is None:
args.seed = random.randint(0, 10000)
cifar10_data.set_random_seed(args.seed)
#output log to writer
writer_train = SummaryWriter(logdir=args.train_log_name)
writer_val = SummaryWriter(logdir=args.val_log_name)
mode = args.type
# Plot for reproduce performance
image_size = 32
plot_perform = plot_utils.Plot_Reproduce_Performance(args.results_path, args.show_n_img_x, args.show_n_img_y, image_size,
image_size, args.show_resize_factor)
show_img_nums = args.show_n_img_x * args.show_n_img_y
show_img = val_data[:show_img_nums, :, :, :]
#show_img = val_data.data[:show_img_nums]
print(show_img.shape) # N * 32 * 32 *3
plot_perform.save_images(show_img, name='input.jpg')
print('saved:', 'input.jpg')
""" training """
batch_size = args.batch_size
epochs = args.num_epochs
num_batches = int(n_samples / batch_size)
for epoch in range(epochs):
encoder.train()
decoder.train()
tot_loss = 0
tot_l2_loss = 0
for i in range(num_batches):
idx = (i * batch_size) % (n_samples)
end_idx = idx + batch_size
batch_input = train_data[idx:end_idx, :, :, :]
batch_target = batch_input
batch_input, batch_target = torch.from_numpy(batch_input).float().to(device), \
torch.from_numpy(batch_target).float().to(device)
y, z, loss, loss_likelihood, loss_divergence, l2_dis = \
vae2.get_loss(encoder, decoder, batch_input, batch_target, mode)
tot_loss = tot_loss + loss.item()
tot_l2_loss = tot_l2_loss + l2_dis.item()
optimizer.zero_grad()
loss.backward()
optimizer.step()
#print cost every epoch
if i == num_batches - 1:
print("train loss: epoch %d: Loss %03.2f L_likelihood %03.2f L_divergence %03.2f L2_dis %03.2f " % (
epoch, loss.item(), loss_likelihood.item(), loss_divergence.item(), l2_dis.item()))
break
tot_loss = tot_loss / float(num_batches)
tot_l2_loss = tot_l2_loss / float(num_batches)
writer_train.add_scalar('loss', tot_loss, epoch)
writer_train.add_scalar('l2_dis', tot_l2_loss, epoch)
#evaluate on val dataset
if (epoch + 1) % 5 == 0 or epoch + 1 == epochs:
encoder.eval()
decoder.eval()
with torch.no_grad():
#calculate the validation loss
val_target = val_data
val_input = val_data
val_input, val_target = torch.from_numpy(val_input).float().to(device), \
torch.from_numpy(val_target).float().to(device)
y_val, z_val, loss_val, loss_likelihood_val, loss_divergence_val, l2_dis_val = \
vae2.get_loss(encoder, decoder, val_input, val_target, mode)
print("test results in val data: epoch %d: Loss %03.2f L_likelihood %03.2f L_divergence %03.2f L2_dis %03.2f " % (
epoch, loss_val.item(), loss_likelihood_val.item(), loss_divergence_val.item(), l2_dis_val.item()))
# Plot for reproduce performance
plot_batch = torch.from_numpy(show_img).float().to(device)
y_PRR = vae2.get_ae(encoder, decoder, plot_batch)
y_PRR_img = y_PRR.reshape(show_img_nums, 3, image_size, image_size)
print(y_PRR_img.shape)
plot_perform.save_images(y_PRR_img.detach().cpu().numpy(), name="/PRR_epoch_%02d" % (epoch) + ".jpg")
print('saved:', "/PRR_epoch_%02d" % (epoch) + ".jpg")
writer_val.add_scalar('loss', loss_val, epoch)
writer_val.add_scalar('l2_dis', l2_dis_val, epoch)
writer_train.close()
writer_val.close()
plot_utils.plot_t_sne(z_val[:100, :].detach().cpu().numpy(), val_data[:100, :, :, :])
plot_utils.plot_t_sne_col(z_val.detach().cpu().numpy(), val_label)
