def main(_):
hps = param()
path_list = [hps.save_path, hps.img_save_path, hps.log_path]
keys = ['run_name', 'epoch', 'batch_size', 'z_dim', 'lr']
for k in keys:
v = FLAGS[k].value
if v is not None:
print('{} value will be changed to; {}'.format(k, v))
setattr(hps, k, v)
if k is 'run_name':
path_list.append(os.path.join(hps.log_path, v))
path_list.append(os.path.join(hps.save_path, v))
path_list.append(os.path.join(hps.img_save_path, v))
make_path(path_list)
train_data, train_size, _, _, test_data, test_labels = mnist_data.prepare_MNIST_data(
)
train_img = train_data[:, :-mnist_data.NUM_LABELS]
train_label = train_data[:, -mnist_data.NUM_LABELS:]
print("INFO: Loaded MNIST data, shape: {}".format(train_data.shape))
with tf.Session() as sess:
model = AdversarialAutoEncoder((train_img, train_label), train_size,
hps, sess)
tf.logging.info("Start Training")
trainer = Trainer((train_img, train_label), train_size, hps, sess,
model)
trainer.learn()
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 test_org(model_directory, batch_size):
# Import data
PIXEL_DEPTH = mnist_data.PIXEL_DEPTH
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(
False)
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
# Calculate accuracy for all mnist test images
test_size = test_labels.shape[0]
total_batch = int(test_size / batch_size)
saver.restore(sess, model_directory)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
def CalculateMSE(x1, x2):
c = tf.square(x1 - x2)
return tf.reduce_mean(c)
n_hidden = 500
IMAGE_SIZE_MNIST = 28
dim_img = IMAGE_SIZE_MNIST ** 2 # number of pixels for a MNIST image
dim_z = 50
# train
n_epochs = 100
batch_size = 128
learn_rate = 0.001
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')
# 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')
last_term = tf.placeholder(tf.float32, shape=[10])
Component_Count = tf.placeholder(tf.float32)
def train():
# Some parameters
batch_size = TRAIN_BATCH_SIZE
num_labels = mnist_data.NUM_LABELS
# Prepare mnist data
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(
True)
# Boolean for MODE of train or test
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
# Predict
y = cnn_model.CNN(x)
# Get loss of model
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y, y_)
# Create a summary to monitor loss tensor
tf.summary.scalar('loss', loss)
# Define optimizer
with tf.name_scope("ADAM"):
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(
1e-4, # Base learning rate.
batch * batch_size, # Current index into the dataset.
train_size, # Decay step.
0.95, # Decay rate.
staircase=True)
# Use simple momentum for the optimization.
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
loss, global_step=batch)
# Create a summary to monitor learning_rate tensor
tf.summary.scalar('learning_rate', learning_rate)
# Get accuracy of model
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Create a summary to monitor accuracy tensor
tf.summary.scalar('acc', accuracy)
# Merge all summaries into a single op
merged_summary_op = tf.summary.merge_all()
# Add ops to save and restore all the variables
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Training cycle
total_batch = int(train_size / batch_size)
# op to write logs to Tensorboard
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY,
graph=tf.get_default_graph())
# Save the maximum accuracy value for validation data
max_acc = 0.
# Loop for epoch
for epoch in range(training_epochs):
# Random shuffling
numpy.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-num_labels]
train_labels_ = train_total_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) % (train_size)
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
# Run optimization op (backprop), loss op (to get loss value)
# and summary nodes
_, train_accuracy, summary = sess.run(
[train_step, accuracy, merged_summary_op],
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: True
})
# Write logs at every iteration
summary_writer.add_summary(summary, epoch * total_batch + i)
# Display logs
if i % display_step == 0:
print(
"Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, training accuracy %.5f" %
(i, total_batch, train_accuracy))
# Get accuracy for validation data
if i % validation_step == 0:
# Calculate accuracy
validation_accuracy = sess.run(accuracy,
feed_dict={
x: validation_data,
y_: validation_labels,
is_training: False
})
print(
"Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, validation accuracy %.5f" %
(i, total_batch, validation_accuracy))
# Save the current model if the maximum accuracy is updated
if validation_accuracy > max_acc:
max_acc = validation_accuracy
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model updated and saved in file: %s" % save_path)
print("Optimization Finished!")
# Restore variables from disk
saver.restore(sess, MODEL_DIRECTORY)
# Calculate accuracy for all mnist test images
test_size = test_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
from __future__ import print_function
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
import mnist_data
from keras.callbacks import ModelCheckpoint
from keras import backend as K
K.set_image_dim_ordering('tf')
batch_size = 128
num_classes = 10
epochs = 12
train_total_data, train_size, validation_data, validation_labels, x_test, y_test = mnist_data.prepare_MNIST_data(
True)
# input image dimensions
img_rows, img_cols = 28, 28
x_train = train_total_data[:, :-10]
y_train = train_total_data[:, -10:]
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
validation_data = validation_data.reshape(validation_data.shape[0], img_rows,
img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
validation_data = validation_data.astype('float32')
def train():
# Some parameters
batch_size = TRAIN_BATCH_SIZE
num_labels = mnist_data.NUM_LABELS
# Prepare mnist data
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(True)
# Boolean for MODE of train or test
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10]) #answer
# Predict
y = cnn_model.CNN(x)
# Get loss of model
with tf.name_scope("LOSS"):
loss = slim.losses.softmax_cross_entropy(y,y_)
# Create a summary to monitor loss tensor
tf.summary.scalar('loss', loss)
# Define optimizer
with tf.name_scope("ADAM"):
# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)
learning_rate = tf.train.exponential_decay(
1e-4, # Base learning rate.
batch * batch_size, # Current index into the dataset.
train_size, # Decay step.
0.95, # Decay rate.
staircase=True)
# Use simple momentum for the optimization.
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss,global_step=batch)
# Create a summary to monitor learning_rate tensor
tf.summary.scalar('learning_rate', learning_rate)
# Get accuracy of model
with tf.name_scope("ACC"):
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# Create a summary to monitor accuracy tensor
tf.summary.scalar('acc', accuracy)
# Merge all summaries into a single op
merged_summary_op = tf.summary.merge_all()
# Add ops to save and restore all the variables
saver = tf.train.Saver()
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Training cycle
total_batch = int(train_size / batch_size)
# op to write logs to Tensorboard
summary_writer = tf.summary.FileWriter(LOGS_DIRECTORY, graph=tf.get_default_graph())
# Save the maximum accuracy value for validation data
max_acc = 0.
# Loop for epoch
for epoch in range(training_epochs):
# Random shuffling
numpy.random.shuffle(train_total_data)
train_data_ = train_total_data[:, :-num_labels]
train_labels_ = train_total_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) % (train_size)
batch_xs = train_data_[offset:(offset + batch_size), :]
batch_ys = train_labels_[offset:(offset + batch_size), :]
# Run optimization op (backprop), loss op (to get loss value)
# and summary nodes
_, train_accuracy, summary = sess.run([train_step, accuracy, merged_summary_op] , feed_dict={x: batch_xs, y_: batch_ys, is_training: True})
# Write logs at every iteration
summary_writer.add_summary(summary, epoch * total_batch + i)
# Display logs
if i % display_step == 0:
print("Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, training accuracy %.5f" % (i, total_batch, train_accuracy))
# Get accuracy for validation data
if i % validation_step == 0:
# Calculate accuracy
validation_accuracy = sess.run(accuracy,
feed_dict={x: validation_data, y_: validation_labels, is_training: False})
print("Epoch:", '%04d,' % (epoch + 1),
"batch_index %4d/%4d, validation accuracy %.5f" % (i, total_batch, validation_accuracy))
# Save the current model if the maximum accuracy is updated
if validation_accuracy > max_acc:
max_acc = validation_accuracy
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model updated and saved in file: %s" % save_path)
print("Optimization Finished!")
# Restore variables from disk
saver.restore(sess, MODEL_DIRECTORY)
# Calculate accuracy for all mnist test images
test_size = test_labels.shape[0]
batch_size = TEST_BATCH_SIZE
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y, feed_dict={x: batch_xs, y_: batch_ys, is_training: False})
correct_prediction = numpy.equal(numpy.argmax(y_final, 1), numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
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
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_tensorflow.autoencoder(x_hat, x, dim_img, dim_z, n_hidden, keep_prob)
# optimization
train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss)
""" training """
if PRR:
PRR = plot_util.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.png')
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.png')
# Plot for manifold learning result
if PMLR and dim_z == 2:
PMLR = plot_util.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_tensorflow.decoder(z_in, dim_img, n_hidden)
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]
for i in range(total_batch):
offset = (i*batch_size)%(n_samples)
batch_xs_input = train_data_[offset:(offset+batch_size),:]
batch_xs_target = batch_xs_input
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("epoch %d: L_tot %03.2f L_likelihood %03.2f L_divergence %03.2f" % (
epoch, tot_loss, loss_likelihood, loss_divergence))
print(" TESTING ")
print(" TESTING ")
import numpy as np
import mnist_data
""" parameters """
n_hidden = 64
dim_img = 28**2 # number of pixels for a MNIST image
batch_size = 128
learn_rate = 0.001
num_epochs = 20
""" prepare MNIST data """
train_data, train_size, _, _, test_data, test_labels =\
mnist_data.prepare_MNIST_data()
n_samples = train_size
""" build graph """
# dropout
keep_prob = tf.placeholder(tf.float32, name='keep_prob')
z_in = tf.placeholder(tf.float32,
shape=[None, dim_img],
name='latent_variable')
c_in = tf.placeholder(tf.float32, shape=[None, 10], name="plmr_confounds")
loss = ffd(z_in, c_in, n_hidden, 10, keep_prob, True)
train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss)
ffd_obj = feed_forward_discriminator_logit(z_in, n_hidden, 10, 1.0, True)
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 test_org(model_directory, batch_size):
# Import data
PIXEL_DEPTH = mnist_data.PIXEL_DEPTH
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(
False)
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
# Calculate accuracy for all mnist test images
test_size = test_labels.shape[0]
total_batch = int(test_size / batch_size)
saver.restore(sess, model_directory)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
# Compute the offset of the current minibatch in the data.
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = sess.run(y, feed_dict={x: batch_xs, y_: batch_ys, is_training: False})
correct_prediction = numpy.equal(numpy.argmax(y_final, 1), numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
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})
def test_ensemble(model_directory_list, batch_size):
# Import data
PIXEL_DEPTH = mnist_data.PIXEL_DEPTH
train_total_data, train_size, validation_data, validation_labels, test_data, test_labels = mnist_data.prepare_MNIST_data(
False)
is_training = tf.placeholder(tf.bool, name='MODE')
is_training = tf.placeholder(tf.bool, name='MODE')
# tf Graph input
x = tf.placeholder(tf.float32, [None, 45 * 45])
y_ = tf.placeholder(tf.float32, [None, 10]) # answer
y = cnn_model.CNN(x, is_training=is_training)
# Add ops to save and restore all the variables
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer(), feed_dict={is_training: True})
# Restore variables from disk
saver = tf.train.Saver()
# Calculate accuracy for all mnist test images
test_size = 10000
total_batch = int(test_size / batch_size)
acc_buffer = []
# Loop over all batches
for i in range(total_batch):
offset = (i * batch_size) % (test_size)
batch_xs = test_data[offset:(offset + batch_size), :]
batch_ys = test_labels[offset:(offset + batch_size), :]
y_final = numpy.zeros_like(batch_ys)
for dir in model_directory_list:
print(dir)
saver.restore(sess, dir + '/model.ckpt')
pred = sess.run(y,
feed_dict={
x: batch_xs,
y_: batch_ys,
is_training: False
})
y_final += one_hot_matrix(
pred) # take a majority vote as an answer
correct_prediction = numpy.equal(numpy.argmax(y_final, 1),
numpy.argmax(batch_ys, 1))
acc_buffer.append(numpy.sum(correct_prediction) / batch_size)
print("test accuracy for the stored model: %g" % numpy.mean(acc_buffer))
