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']
# 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
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
DEVICE = args['DEVICE'] # set device
p_zeroed = args['p_zeroed']
""" prepare Ascent_MNIST data """
dataset = Ascent_MNISTdataset()
train_loader = torch.utils.data.DataLoader(dataset,
batch_size=args['batch_size'],
shuffle=True,
num_workers=0)
# Teacher classifier
model_path = 'C://Users//KIMHAKBIN//Documents//PycharmProjects//Activation_Maximization//pretrained//mnist.pth.tar'
classifier = LeNet5()
load_checkpoints(classifier, model_path, DEVICE)
# encoder
AutoEncoder = VAEcore.autoencoder(dim_img, dim_z, n_hidden, p_zeroed)
# networks
networks = (classifier, AutoEncoder)
# optimizer
optimizer = optim.Adam(AutoEncoder.parameters(), learn_rate)
# 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)
# train per epoch
min_trn_loss = 1e99
for epoch in range(1, n_epochs + 1):
trn_acc, trn_loss = train_epoch(networks, optimizer, train_loader,
batch_size)
print('Iteration:', epoch, '\t', 'Accuaracy:', trn_acc, '\t', 'Loss:',
trn_loss)
# if minimum loss is updated or final epoch, plot results
if min_trn_loss > np.sum(trn_loss) or epoch + 1 == n_epochs:
min_trn_loss = np.sum(trn_loss)
# Plot for manifold learning result
if PMLR and dim_z == 2:
AutoEncoder.eval() # p_zeroed를 0으로 만들어 줘야함
z = torch.from_numpy(PMLR.z).float()
y_PMLR = AutoEncoder.Decoder(z)
y_PMLR_img = y_PMLR.reshape(PMLR.n_tot_imgs, IMAGE_SIZE_MNIST,
IMAGE_SIZE_MNIST)
y_PMLR_img = y_PMLR_img.detach().numpy()
PMLR.save_images(y_PMLR_img,
name="/PMLR_epoch_%02d" % (epoch) + ".jpg")
print('Training Finish!!')
def build_model(self):
# some parameters
image_dims = [self.input_height, self.input_width, self.c_dim]
bs = self.batch_size
""" Graph Input """
# images
self.inputs = tf.placeholder(tf.float32, [bs] + image_dims,
name='real_images')
# noises
self.z = tf.placeholder(tf.float32, [bs, self.z_dim], name='z')
""" Loss Function """
# output of D for real images
D_real, D_real_logits, _ = self.discriminator(self.inputs,
is_training=True,
reuse=False)
# output of D for fake images
G = self.generator(self.z, is_training=True, reuse=False)
D_fake, D_fake_logits, _ = self.discriminator(G,
is_training=True,
reuse=True)
# get loss for discriminator
d_loss_real = -tf.reduce_mean(D_real_logits)
d_loss_fake = tf.reduce_mean(D_fake_logits)
self.d_loss = d_loss_real + d_loss_fake
# get loss for generator
self.g_loss = -d_loss_fake
""" Training """
# divide trainable variables into a group for D and a group for G
t_vars = tf.trainable_variables()
d_vars = [var for var in t_vars if 'd_' in var.name]
g_vars = [var for var in t_vars if 'g_' in var.name]
# optimizers
with tf.control_dependencies(tf.get_collection(
tf.GraphKeys.UPDATE_OPS)):
self.d_optim = tf.train.AdamOptimizer(self.learning_rate, beta1=self.beta1) \
.minimize(self.d_loss, var_list=d_vars)
self.g_optim = tf.train.AdamOptimizer(self.learning_rate*5, beta1=self.beta1) \
.minimize(self.g_loss, var_list=g_vars)
# weight clipping
self.clip_D = [
p.assign(tf.clip_by_value(p, -0.01, 0.01)) for p in d_vars
]
"""" Testing """
# for test
self.fake_images = self.generator(self.z,
is_training=False,
reuse=True)
self.z_in = tf.placeholder(tf.float32, [1, self.z_dim], name='z_in')
self.y_out = self.generator(self.z_in, is_training=False, reuse=True)
self.y0 = tf.placeholder(tf.float32, [1, 28, 28, 1], name='y0')
self.f = tf.reduce_sum(tf.square(self.y_out - self.y0))
self.gradient = tf.gradients(ys=self.f, xs=self.z_in)
""" Summary """
d_loss_real_sum = tf.summary.scalar("d_loss_real", d_loss_real)
d_loss_fake_sum = tf.summary.scalar("d_loss_fake", d_loss_fake)
d_loss_sum = tf.summary.scalar("d_loss", self.d_loss)
g_loss_sum = tf.summary.scalar("g_loss", self.g_loss)
# final summary operations
self.g_sum = tf.summary.merge([d_loss_fake_sum, g_loss_sum])
self.d_sum = tf.summary.merge([d_loss_real_sum, d_loss_sum])
# Plot for manifold learning result
if self.z_dim == 2:
self.PMLR = plot_utils.Plot_Manifold_Learning_Result(
self.result_dir, 20, 20, 28, 28, 1.0, 1.0) #change to 1
# saver to save model
self.saver = tf.train.Saver(max_to_keep=1000)
def build_model(self):
# some parameters
image_dims = [self.input_height, self.input_width, self.c_dim]
bs = self.batch_size
""" Graph Input """
# images
self.inputs = tf.placeholder(tf.float32, [bs] + image_dims, name='real_images')
# noises
self.z = tf.placeholder(tf.float32, [bs, self.z_dim], name='z')
""" Loss Function """
# output of D for real images
D_real, D_real_logits, _ = self.discriminator(self.inputs, is_training=True, reuse=False)
# output of D for fake images
G = self.generator(self.z, is_training=True, reuse=False)
D_fake, D_fake_logits, _ = self.discriminator(G, is_training=True, reuse=True)
# get loss for discriminator
d_loss_real = - tf.reduce_mean(D_real_logits)
d_loss_fake = tf.reduce_mean(D_fake_logits)
self.d_loss = d_loss_real + d_loss_fake
# get loss for generator
self.g_loss = - d_loss_fake
""" Gradient Penalty """
# This is borrowed from https://github.com/kodalinaveen3/DRAGAN/blob/master/DRAGAN.ipynb
alpha = tf.random_uniform(shape=self.inputs.get_shape(), minval=0.,maxval=1.)
differences = G - self.inputs # This is different from MAGAN
interpolates = self.inputs + (alpha * differences)
_,D_inter,_=self.discriminator(interpolates, is_training=True, reuse=True)
gradients = tf.gradients(D_inter, [interpolates])[0]
slopes = tf.sqrt(tf.reduce_sum(tf.square(gradients), reduction_indices=[1]))
gradient_penalty = tf.reduce_mean((slopes - 1.) ** 2)
self.d_loss += self.lambd * gradient_penalty
""" Training """
# divide trainable variables into a group for D and a group for G
t_vars = tf.trainable_variables()
d_vars = [var for var in t_vars if 'd_' in var.name]
g_vars = [var for var in t_vars if 'g_' in var.name]
# optimizers
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
self.d_optim = tf.train.AdamOptimizer(self.learning_rate, beta1=self.beta1) \
.minimize(self.d_loss, var_list=d_vars)
self.g_optim = tf.train.AdamOptimizer(self.learning_rate*5, beta1=self.beta1) \
.minimize(self.g_loss, var_list=g_vars)
"""" Testing """
# for test
self.fake_images = self.generator(self.z, is_training=False, reuse=True)
self.z_in = tf.placeholder(tf.float32, [1, self.z_dim], name='z_in')
self.y_out = self.generator(self.z_in, is_training=False, reuse=True)
self.y0 = tf.placeholder(tf.float32, [1, 28, 28, 1], name='y0')
self.f = tf.reduce_sum(tf.square(self.y_out - self.y0))
self.gradient = tf.gradients(ys = self.f, xs = self.z_in)
""" Summary """
d_loss_real_sum = tf.summary.scalar("d_loss_real", d_loss_real)
d_loss_fake_sum = tf.summary.scalar("d_loss_fake", d_loss_fake)
d_loss_sum = tf.summary.scalar("d_loss", self.d_loss)
g_loss_sum = tf.summary.scalar("g_loss", self.g_loss)
# final summary operations
self.g_sum = tf.summary.merge([d_loss_fake_sum, g_loss_sum])
self.d_sum = tf.summary.merge([d_loss_real_sum, d_loss_sum])
# Plot for manifold learning result
if self.z_dim == 2:
self.PMLR = plot_utils.Plot_Manifold_Learning_Result(check_folder(self.result_dir + '/' + self.model_dir), 20, 20, 28, 28, 1.0, 1.0) #change to 1
# saver to save model
self.saver = tf.train.Saver(max_to_keep=1000)
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 build_model(self):
# some parameters
image_dims = [self.input_height, self.input_width, self.c_dim]
bs = self.batch_size
""" Graph Input """
# images
self.inputs = tf.placeholder(tf.float32, [bs] + image_dims, name='real_images')
# noises
self.z = tf.placeholder(tf.float32, [bs, self.z_dim], name='z')
""" Loss Function """
# encoding
self.mu, sigma = self.encoder(self.inputs, is_training=True, reuse=False)
# sampling by re-parameterization technique
z = self.mu + sigma * tf.random_normal(tf.shape(self.mu), 0, 1, dtype=tf.float32)
# decoding
out = self.decoder(z, is_training=True, reuse=False)
self.out = tf.clip_by_value(out, 1e-8, 1 - 1e-8)
# loss
marginal_likelihood = tf.reduce_sum(self.inputs * tf.log(self.out) + (1 - self.inputs) * tf.log(1 - self.out),
[1, 2])
KL_divergence = 0.5 * tf.reduce_sum(tf.square(self.mu) + tf.square(sigma) - tf.log(1e-8 + tf.square(sigma)) - 1, [1])
self.neg_loglikelihood = -tf.reduce_mean(marginal_likelihood)
self.KL_divergence = tf.reduce_mean(KL_divergence)
ELBO = -self.neg_loglikelihood - self.KL_divergence
self.loss = -ELBO
""" Training """
# optimizers
t_vars = tf.trainable_variables()
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
self.optim = tf.train.AdamOptimizer(self.learning_rate*5, beta1=self.beta1) \
.minimize(self.loss, var_list=t_vars)
"""" Testing """
# for test
self.fake_images = self.decoder(self.z, is_training=False, reuse=True)
self.z_in = tf.placeholder(tf.float32, [1, self.z_dim], name='z_in')
self.y_out = self.decoder(self.z_in, is_training=False, reuse=True)
self.y0 = tf.placeholder(tf.float32, [1, 28, 28, 1], name='y0')
self.f = tf.reduce_sum(tf.square(self.y_out - self.y0))
self.gradient = tf.gradients(ys = self.f, xs = self.z_in)
""" Summary """
nll_sum = tf.summary.scalar("nll", self.neg_loglikelihood)
kl_sum = tf.summary.scalar("kl", self.KL_divergence)
loss_sum = tf.summary.scalar("loss", self.loss)
# final summary operations
self.merged_summary_op = tf.summary.merge_all()
# Plot for manifold learning result
if self.z_dim == 2:
self.PMLR = plot_utils.Plot_Manifold_Learning_Result(self.result_dir, 20, 20, 28, 28, 1.0, 2.0)
# saver to save model
self.saver = tf.train.Saver(max_to_keep = 1000)
