def test(self, save_dir):
# init variables
tf.global_variables_initializer().run()
if not os.path.exists(save_dir):
os.makedirs(save_dir)
load_model_status, global_step = self.load(self.ckpt_dir)
assert load_model_status == True, '[!] Loading weights FAILED...'
print(" [*] Loading weights SUCCESS...")
test_set = np.reshape(self.dataset.test.images, [-1, 28, 28, 1])
test_corrupt = test_set + np.random.normal(
0, self.sigma / 255.0, np.shape(test_set)).astype('float32')
feed_dict_test = {self.Y: test_corrupt}
recon = self.sess.run(self.Y_, feed_dict=feed_dict_test)
groundtruth = np.clip(255 * np.squeeze(test_set), 0,
255).astype('uint8')
outputimage = np.clip(255 * np.squeeze(recon), 0, 255).astype('uint8')
# calculate PSNR
avg_psnr_test = cal_psnr(groundtruth, outputimage)
#saving sample images
ims(save_dir + "/denoised.png", merge(outputimage[:100], [10, 10]))
ims(save_dir + "/noisy.png",
merge(np.squeeze(test_corrupt)[:100], [10, 10]))
print("---- TEST SET ---- Average PSNR %.3f ---" % avg_psnr_test)
def train(self):
for i in range(self.trials):
visualization = self.mnist.test.next_batch(self.batchsize)[0]
reshaped_vis = visualization.reshape(self.batchsize,128,128)
base_dir = "reconstruction_"+str(i)+ "/"
if not os.path.exists(base_dir):
os.makedirs(base_dir)
ims(base_dir+"base.jpg",merge(reshaped_vis[:64],[8,8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
generation_loss = []
latent_loss = []
sess.run(tf.initialize_all_variables())
for epoch in range(self.epoch):
for idx in range(int(self.n_samples / self.batchsize)):
batch = self.mnist.train.next_batch(self.batchsize)[0]
_, gen_loss, lat_loss = sess.run((self.optimizer, self.generation_loss, self.latent_loss), feed_dict={self.images: batch})
# dumb hack to print cost every epoch
if idx % (self.n_samples - 3) == 0:
print "epoch %d: genloss %f latloss %f" % (epoch, np.mean(gen_loss), np.mean(lat_loss))
generation_loss.append(np.mean(gen_loss))
latent_loss.append(np.mean(lat_loss))
saver.save(sess, os.getcwd()+"/training/train",global_step=epoch)
generated_test = sess.run(self.generated_images, feed_dict={self.images: visualization})
generated_test = generated_test.reshape(self.batchsize,128,128)
ims(base_dir+str(epoch)+".jpg",merge(generated_test[:64],[8,8]))
gen_loss_file = open('gen_loss_'+str(self.n_z)+'_latent.txt', 'w')
lat_loss_file = open('lat_loss_'+str(self.n_z)+'_latent.txt', 'w')
for item in generation_loss:
gen_loss_file.write("%s\n" % item)
for item in latent_loss:
lat_loss_file.write("%s\n" % item)
return
def train(self):
# get images, not labels
visualization = self.mnist.train.next_batch(self.batchsize)[0]
reshaped_vis = visualization.reshape(self.batchsize, 28, 28)
ims("results/base.jpg", merge(reshaped_vis[:64], [8, 8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
for epoch in range(10):
for idx in range(int(self.n_samples / self.batchsize)):
batch = self.mnist.train.next_batch(self.batchsize)[0]
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss,
self.latent_loss),
feed_dict={self.images: batch})
# dumb hack to print cost every epoch
if idx % (self.n_samples - 3) == 0:
print "epoch %d: genloss %f latloss %f" % (
epoch, np.mean(gen_loss), np.mean(lat_loss))
saver.save(sess,
os.getcwd() + "/training/train",
global_step=epoch)
# there is a problem in this code
# except for the first epoch, visualization could be used as training data
# which is logically incorrect.
# predict something that's already appeared in the training data is wrong
generated_test = sess.run(
self.generated_images,
feed_dict={self.images: visualization})
generated_test = generated_test.reshape(
self.batchsize, 28, 28)
ims("results/" + str(epoch) + ".jpg",
merge(generated_test[:64], [8, 8]))
def evaluate(self, valid_corrupt, iter_num, summary_merged,
summary_writer):
feed_dict_eval = {self.X: self.valid_set, self.Y: valid_corrupt}
valid_output, valid_mse, valid_sure = self.sess.run(
[self.Y_, self.mse, self.sure], feed_dict=feed_dict_eval)
groundtruth = np.clip(255 * np.squeeze(self.valid_set), 0,
255).astype('uint8')
noisyimage = np.clip(255 * np.squeeze(valid_corrupt), 0,
255).astype('uint8')
outputimage = np.clip(255 * np.squeeze(valid_output), 0,
255).astype('uint8')
# calculate PSNR
avg_psnr = cal_psnr(groundtruth, outputimage)
psnr_summary = self.sess.run(summary_merged,
feed_dict={self.eval_psnr: avg_psnr})
summary_writer.add_summary(psnr_summary, iter_num)
#saving sample images
ims(self.sample_dir + "/" + str(iter_num) + ".png",
merge(outputimage[:100], [10, 10]))
print("VALID, mse: %.6f, sure: %.6f" % (valid_mse, valid_sure))
print("---- Validation Set ---- Average PSNR %.3f ---" % avg_psnr)
def train(self):
visualization = self.mnist.train.next_batch(self.batchsize)[0]
reshaped_vis = visualization.reshape(self.batchsize, 28, 28)
ims("results/base.jpg", merge(reshaped_vis[:64], [8, 8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
for epoch in range(10):
for idx in range(int(self.n_samples / self.batchsize)):
batch = self.mnist.train.next_batch(self.batchsize)[0]
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss,
self.latent_loss),
feed_dict={self.images: batch})
# dumb hack to print cost every epoch
if idx % (self.n_samples - 3) == 0:
print "epoch %d: genloss %f latloss %f" % (
epoch, np.mean(gen_loss), np.mean(lat_loss))
saver.save(sess,
os.getcwd() + "/training/train",
global_step=epoch)
generated_test = sess.run(
self.generated_images,
feed_dict={self.images: visualization})
generated_test = generated_test.reshape(
self.batchsize, 28, 28)
def build_model():
""" Graph Input """
IMG = tf.placeholder(tf.float32, [None, 100 * 100])
# train data
imgpath = '/home/lu/cs/DCASE_NEW/DATA/data1/newtrain1/'
img_arr, lab_arr = GetFlatPix(imgpath) # (17750,10000),(17750,15)
n_train = img_arr.shape[0]
'''encoding'''
mu, sigma = Encoder(IMG, reuse=False)
'''sampling by re-parameterization technique'''
eps = tf.random_normal(shape=tf.shape(mu)) #defaut 0-1,float32
z = mu + tf.exp(sigma / 2) * eps
'''decoding'''
out_img = Decoder(z, reuse=False)
out_flat = tf.reshape(out_img, [-1, 100 * 100])
'''vae_loss'''
recon_loss = tf.reduce_sum(tf.squared_difference(out_flat, IMG), 1)
kl_loss = 0.5 * tf.reduce_sum(
tf.exp(sigma) - 1. - sigma + tf.square(mu), 1)
vae_loss = tf.reduce_mean(recon_loss + kl_loss)
""" Training """
# optimizers
optimizer = tf.train.AdamOptimizer(learning_rate=1e-3).minimize(vae_loss)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# 如果当前的路径下不存在out这个文件夹，就创建它
if not os.path.exists('results/'):
os.makedirs('results/')
for step in range(100000):
start = (step * batch_size) % n_train
end = min(start + batch_size, n_train)
_, total_loss, RE_loss, KL_loss = sess.run(
[optimizer, vae_loss, recon_loss, kl_loss],
feed_dict={IMG: img_arr[start:end]})
if step % 1000 == 0: # train
print('step:%d,Total_Loss:%f,RE_loss:%f,KL_loss:%f' %
(step, total_loss, np.mean(RE_loss), np.mean(KL_loss)))
# test
"""" Testing """
# # Sampling from random z 训练好了之后，把decoder单独拿出来，把z丢给他
ZN = tf.placeholder(tf.float32, [None, n_latent])
fake_images = Decoder(ZN, reuse=True)
z_batch = np.random.normal(0., 1, (batch_size, n_latent)).astype(
np.float32)
samples = sess.run(fake_images, feed_dict={ZN: z_batch})
samples_img = np.reshape(samples, (-1, 100, 100, 1))
from scipy.misc import imsave as ims
# 显示生成的图片
ims("./results/" + str(step) + ".jpg",
merge(samples_img[0:batch_size], [8, 8]))
def save_imgs(self, epoch):
r, c = 3, 3
noise = np.random.normal(0, 1, (r * c, 100))
gen_imgs = self.generator.predict(noise)
# Rescale images 0 - 1
gen_imgs = 0.5 * gen_imgs + 0.5
#ims("images/pokemon_%d.png" % epoch,utils.merge(gen_imgs,[3,3]))
ims('images/pokemon_%d.png'%epoch, utils.merge(gen_imgs,[3,3]))
def train(self):
for i in xrange(15000):
xtrain, _ = self.mnist.train.next_batch(self.batch_size)
cs, gen_loss, lat_loss, _ = self.sess.run([self.cs, self.generation_loss, self.latent_loss, self.train_op], feed_dict={self.images: xtrain})
if i % 300 == 0:
print "iter %d genloss %f latloss %f" % (i, gen_loss, lat_loss)
results = np.transpose(np.array(cs),[0,1,2])[-1]
results_square = np.reshape(results, [-1, 28, 28])
print results_square.shape
ims("results/"+str(i)+".jpg",merge(results_square,[8,8]))
def merge(images, size):
h, w = images.shape[1], images.shape[2]
img = np.zeros((h * size[0], w * size[1]))
for idx, image in enumerate(images):
i = idx % size[1]
j = idx / size[1]
img[j*h:j*h+h, i*w:i*w+w] = image
ims("individual_images/" + str(idx)+".jpg", image)
return img
def train(self):
self.validation_error = 100000.0
try:
data = self.mnist.train
if self.n_test == 0:
validation, val_labels = next_batch_partial(
data, self.batchsize, self.n_train)
else:
validation = data.images[self.n_train:]
val_labels = data.labels[self.n_train:]
reshaped_val = validation.reshape(-1, 28, 28)
ims(os.path.join(self.results_dir, "base.jpg"),
merge(reshaped_val[:64], [8, 8]))
# train
self.best = None
self.best_epoch = 0
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
last_epochs_completed = -1
while(
data.epochs_completed < self.max_epochs and
data.epochs_completed - self.best_epoch <
self.max_epochs_without_improvement
):
if math.isnan(float(self.validation_error)):
# Quit early on nan since it will just propagate
# and be the final result anyway
break
batch, batch_labels = next_batch_partial(
data, self.batchsize, self.n_train)
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.calc_generation_loss,
self.calc_latent_loss),
feed_dict={self.images: batch})
if last_epochs_completed != data.epochs_completed:
last_epochs_completed = data.epochs_completed
self.print_epoch(
last_epochs_completed, gen_loss, lat_loss,
saver, sess, validation
)
except Exception:
print("Exception occurred.")
self.validation_error = 100000.0
def test_imgs(self):
r, c = 3, 3
noise = np.random.normal(0, 1, (r * c, 100))
# load json and create model
json_file = open('weights/generator.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)
weightlist = glob.glob('weights/*.h5')
cnt = 0
for weight in weightlist:
# load weights into new model
loaded_model.load_weights(weight)
gen_imgs = self.generator.predict(noise)
# Rescale images 0 - 1
gen_imgs = 0.5 * gen_imgs + 0.5
ims('images/test_pokemon_%d.png'%cnt, utils.merge(gen_imgs,[3,3]))
cnt = cnt+save_interval
def train(self):
#visualization = self.mnist.train.next_batch(self.batch_size)[0] # we do not need label (= [1])
visualization = self.mnist.test.next_batch(
self.batch_size)[0] # we do not need label (= [1])
reshaped_vis = visualization.reshape(self.batch_size, 28, 28)
# get first 64 images and merge in to one image of 8 x 8 grid, and SAVE
# for reference to compare generated images
ims("results/base.jpg", merge(reshaped_vis[:64], [8, 8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(self.epoch):
for idx in range(self.train_num):
batch = self.mnist.train.next_batch(self.batch_size)[0]
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss,
self.latent_loss),
feed_dict={self.images: batch})
# dumb hack to print cost every epoch
# if idx % (self.n_samples - 3) == 0: # original code. it works, but it seems wrong
if idx % (self.train_num - 3) == 0:
print("epoch %d: gen_loss %f lat_loss %f" %
(epoch, np.mean(gen_loss), np.mean(lat_loss)))
saver.save(sess,
os.getcwd() + "/training/train",
global_step=epoch)
# generate test
generated_test = sess.run(
self.generated_images,
feed_dict={self.images: visualization})
generated_test = generated_test.reshape(
self.batch_size, 28, 28)
ims("results/" + str(epoch) + ".jpg",
merge(generated_test[:64], [8, 8]))
def train(self):
visualization = self.mnist.train.next_batch(self.batchsize)[0]
reshaped_vis = visualization.reshape(self.batchsize, 28, 28)
print(np.shape(reshaped_vis))
ims('results/base2.jpg', merge(reshaped_vis[:64], [8, 8]))
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(10):
for idx in range(int(self.n_samples / self.batchsize)):
batch = self.mnist.train.next_batch(self.batchsize)[0]
_, gen_loss, lat_loss = sess.run((self.optimizer, self.generation_loss, self.latent_loss),
feed_dict={self.images: batch})
if idx % (self.n_samples - 3) == 0:
print('epoch %d: genloss %f latloss %f' % (epoch, np.mean(gen_loss), np.mean(lat_loss)))
saver.save(sess, os.getcwd()+'training/train', global_step=epoch)
generated_test = sess.run(self.generated_images, feed_dict={self.images: visualization})
generated_test = generated_test.reshape(self.batchsize, 28, 28)
ims('result/' + str(epoch) + '.jpg', merge(generated_test[:64], [8, 8]))
def train(self):
train_loss_d = train_loss_g = train_loss_vae = 0.5
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
n_samples = mnist.train.num_examples
for epoch in range(10):
for idx in range(int(n_samples / self.batchsize)):
# z = np.random.uniform(-1.0,1.0, size=(self.batchsize, self.zdim)).astype(np.float32)
batch = mnist.train.next_batch(self.batchsize)[0].reshape([self.batchsize,self.imgdim,self.imgdim,1])
for i in xrange(4):
train_loss_g, _ = self.sess.run([self.g_loss, self.g_optim],feed_dict={self.images: batch})
train_loss_d, _ = self.sess.run([self.d_loss, self.d_optim],feed_dict={self.images: batch})
train_loss_vae, _ = self.sess.run([self.vae_loss, self.vae_optim],feed_dict={self.images: batch})
print "%d: %f %f %f" % (idx, train_loss_d, train_loss_g, train_loss_vae)
if idx % 15 == 0:
generated_test = self.sess.run(self.G, feed_dict={self.images: batch})
generated_test = generated_test.reshape(self.batchsize,28,28)
ims("results/"+str(idx + epoch*100000)+".jpg",merge(generated_test[:64],[8,8]))
def train(self):
next_batch = get_test_images(digits_low_samples, self.batchsize)
visualization = next(next_batch)
print(visualization.shape)
reshaped_vis = visualization.reshape(self.batchsize, 28, 28)
ims("results/base.jpg", merge(reshaped_vis[:64], [8, 8]))
# train
saver = tf.train.Saver(max_to_keep=2)
self.sess = tf.Session()
sess = self.sess
sess.run(tf.global_variables_initializer())
for epoch in range(1000):
batch = next(next_batch)
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss, self.latent_loss),
feed_dict={self.images: batch})
if epoch % 100 == 0:
print("epoch %d: genloss %f latloss %f" %
(epoch, np.mean(gen_loss), np.mean(lat_loss)))
saver.save(sess,
os.getcwd() + "/training/train",
global_step=epoch)
generated_test = sess.run(
self.generated_images,
feed_dict={self.images: visualization})
generated_test = generated_test.reshape(self.batchsize, 28, 28)
ims("results/" + str(epoch) + ".jpg",
merge(generated_test[:64], [8, 8]))
sample_images = sess.run(
self.sample_images,
feed_dict={self.num_samples: num_low_samples_digits_generate})
np.save("../vae_samples.npy", np.reshape(sample_images, (-1, 28 * 28)))
sample_images = sample_images.reshape(num_low_samples_digits_generate,
28, 28)
ims("results/" + "vae_samples.jpg", merge(sample_images[:64], [8, 8]))
def print_epoch(self, epoch, gen_loss, lat_loss, saver, sess,
validation):
saver.save(sess, os.path.join(self.results_dir, 'checkpoints',
'checkpoint'),
global_step=epoch)
val_ims, val_error = sess.run(
[self.generate_images, self.calc_generation_loss],
feed_dict={self.images: validation})
fn="{:04d}.jpg".format(epoch)
ims(os.path.join(self.results_dir, fn),
merge(val_ims.reshape(-1, 28, 28)[:64], [8, 8]))
self.validation_error = float(np.mean(val_error))
print("epoch {:02d}: genloss {:7.3f} latloss {:7.3f} "
"validation_genloss {:7.3f}".format(
epoch,
np.mean(gen_loss), np.mean(lat_loss), self.validation_error))
if self.best is None or self.validation_error < self.best:
self.best_epoch = epoch
self.best = self.validation_error
def train():
visualization = mnist.train.next_batch(batchsize)[0]
reshaped_vis = visualization.reshape(batchsize, 28, 28)
print(reshaped_vis.shape)
ims("results/base.jpg", merge(reshaped_vis[:64], [8, 8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for epoch in range(epochs):
for idx in range(int(n_samples / batchsize)):
batch = mnist.train.next_batch(batchsize)[0]
_, gen_loss, lat_loss = sess.run(
(optimizer, generation_loss, KL_loss),
feed_dict={images: batch})
# dumb hack to print cost every epoch
if idx % (n_samples - 3) == 0:
print("epoch %d: genloss %f latloss %f" %
(epoch, np.mean(gen_loss), np.mean(lat_loss)))
saver.save(sess,
os.getcwd() + "/training/train",
global_step=epoch)
generated_test = sess.run(
generated_images, feed_dict={images: visualization})
generated_test = generated_test.reshape(batchsize, 28, 28)
ims("results/" + str(epoch) + ".jpg",
merge(generated_test[:64], [8, 8]))
x_sample, y_sample = mnist.test.next_batch(2000)
z_mu = sess.run(z_mean, feed_dict={images: x_sample})
print(z_mu.shape, '===')
plt.figure(figsize=(8, 6))
plt.scatter(z_mu[:, 0], z_mu[:, 1], c=y_sample)
plt.colorbar()
plt.grid()
plt.show()
def train(self):
visualization_im, visualization_lab = self.mnist.train.next_batch(self.batchsize)
reshaped_vis_im = visualization_im.reshape(self.batchsize,28,28)
ims("results/base.jpg",merge(reshaped_vis_im[:64],[8,8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
for epoch in range(30):
for idx in range(int(self.n_samples / self.batchsize)):
batch_images, batch_labels = self.mnist.train.next_batch(
self.batchsize)
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss,
self.latent_loss), feed_dict={
self.images: batch_images,
self.labels: batch_labels})
# dumb hack to print cost every epoch
if idx % (self.n_samples - 3) == 0:
print("epoch {}: genloss {} latloss {}".format(epoch, np.mean(gen_loss), np.mean(lat_loss)))
saver.save(sess, os.getcwd()+"/training/train",global_step=epoch)
generated_test = sess.run(self.generated_images, feed_dict={self.images: visualization_im, self.labels: visualization_lab})
generated_test = generated_test.reshape(self.batchsize,28,28)
ims("results/"+str(epoch)+".jpg",merge(generated_test[:64],[8,8]))
d_optim = tf.train.AdamOptimizer(learningrate, beta1=beta1).minimize(d_loss, var_list=d_vars)
g_optim = tf.train.AdamOptimizer(learningrate, beta1=beta1).minimize(g_loss, var_list=g_vars)
tf.global_variables_initializer().run()
saver = tf.train.Saver(max_to_keep=10)
counter = 1
start_time = time.time()
display_z = np.random.uniform(-1, 1, [batchsize, Z_DIM]).astype(np.float32)
realfiles = data[0:64]
realim = [get_image(batch_file, 64, 64) for batch_file in realfiles]
real_img = np.array(realim).astype(np.float32)
ims("results/imagenet/real.jpg", merge(real_img,[8,8]))
if train:
for epoch in range(10):
batch_idx = (len(data)//batchsize)-2
for idx in range(batch_idx):
batch_files = data[idx*batchsize:(idx+1)*batchsize]
batchim = [get_image(batch_file, 64, 64) for batch_file in batch_files]
batch_images = np.array(batchim).astype(np.float32)
batch_z = np.random.uniform(-1, 1, [batchsize, Z_DIM]).astype(np.float32)
sess.run([d_optim],feed_dict={ images: batch_images, zin: batch_z })
sess.run([g_optim],feed_dict={ zin: batch_z })
counter += 1
def test(self):
with tf.Session() as sess:
self.saver = tf.train.Saver()
self.sess = sess
sess.run(tf.global_variables_initializer())
self.saver.restore(sess, 'models/TeacherStudent_MNIST_TO_Fashion')
myPredict = self.predict()
myIndex = 2
testX = np.concatenate(
(self.mnist_train_x, self.mnistFashion_train_x), axis=0)
testY = np.concatenate(
(self.mnist_train_y, self.mnistFashion_train_y), axis=0)
index = [i for i in range(np.shape(testX)[0])]
random.shuffle(index)
testX = testX[index]
testY = testY[index]
batch_z = np.random.uniform(
-1, 1, [self.batch_size, self.z_dim]).astype(np.float32)
g_outputs = self.sess.run(self.GAN_output,
feed_dict={
self.inputs:
testX[0:self.batch_size],
self.z: batch_z,
self.y: testY[0:self.batch_size]
})
g_outputs = np.reshape(g_outputs, (-1, 28, 28, 1))
ims("results/" + "mnistToFashion_gan" + str(0) + ".png",
merge(g_outputs[:36], [6, 6]))
real1 = testX[0:self.batch_size]
my11 = np.reshape(real1, (-1, 28, 28, 1))
ims("results/" + "mnistToFashion_real" + str(0) + ".png",
merge(my11[:36], [6, 6]))
my11 = self.sess.run(
self.output1,
feed_dict={self.inputs: testX[0:self.batch_size]})
my11 = np.reshape(my11, (-1, 28, 28, 1))
ims("results/" + "mnistToFashion_reco" + str(0) + ".png",
merge(my11[:36], [6, 6]))
mnistAccuracy = self.Calculate_accuracy(self.mnist_test_x,
self.mnist_label_test)
mnistFashionAccuracy = self.Calculate_accuracy(
self.mnistFashion_test_x, self.mnistFashion_test_labels)
z_mean, z_log_sigma_sq = My_Encoder_mnist(self.inputs,
"encoder1",
batch_size=64,
reuse=True)
continous_variables = z_mean + z_log_sigma_sq * tf.random_normal(
tf.shape(z_mean), 0, 1, dtype=tf.float32)
z_in = tf.placeholder(tf.float32, [self.batch_size, self.z_dim])
code1 = tf.concat((z_in, self.y, self.labels), axis=1)
reco1 = Generator_mnist("generator1", code1, reuse=True)
myTest_x = self.mnist_train_x[0:self.batch_size]
myTest_y = self.mnist_train_y[0:self.batch_size]
myTest_label = self.mnist_label[0:self.batch_size]
myindex = 10
myTest_x = self.mnistFashion_train_x[myindex *
self.batch_size:(myindex +
1) *
self.batch_size]
myTest_y = self.mnistFashion_train_y[myindex *
self.batch_size:(myindex +
1) *
self.batch_size]
myTest_label = self.mnistFashion_label[myindex *
self.batch_size:(myindex +
1) *
self.batch_size]
minx = -2.0
minx = 0
diff = 4.0 / 64.0
for i in range(32):
myNew = []
myCodes = sess.run(continous_variables,
feed_dict={self.inputs: myTest_x})
for j in range(64):
myCodes[0, i] = minx + j * diff
reco = sess.run(reco1,
feed_dict={
z_in: myCodes,
self.y: myTest_y,
self.labels: myTest_label
})
myNew.append(reco[0])
myNew = np.array(myNew)
myNew = np.reshape(myNew, (-1, 28, 28))
ims("results/" + "PPP" + str(i) + ".png",
merge(myNew[:64], [8, 8]))
bc = 0
def train(self):
visualization = self.mnist.train.next_batch(self.batchsize)[0]
reshaped_vis = visualization.reshape(self.batchsize, 28, 28)
ims("results/base.jpg", merge(reshaped_vis[:64], [8, 8]))
# train
saver = tf.train.Saver(max_to_keep=2)
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
for epoch in range(10):
for idx in range(int(self.n_samples / self.batchsize)):
batch = self.mnist.train.next_batch(self.batchsize)[0]
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss,
self.latent_loss),
feed_dict={self.images: batch})
# dumb hack to print cost every epoch
if idx % (self.n_samples - 3) == 0:
print "epoch %d: genloss %f latloss %f" % (
epoch, np.mean(gen_loss), np.mean(lat_loss))
saver.save(sess,
os.getcwd() + "/training/train",
global_step=epoch)
generated_test = sess.run(
self.generated_images,
feed_dict={self.images: visualization})
generated_test = generated_test.reshape(
self.batchsize, 28, 28)
ims("results/" + str(epoch) + ".jpg", merge(generated_test[:64], [8, 8]))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9})
lastvalue = np.ones((4))
if isWeight:
saver.restore(sess, 'models/Dropout_Sinmple_6_Gaussian')
tIndex = 7
x_fixed = x_train[batch_size * tIndex:batch_size * tIndex + batch_size]
x_fixed = x_test[batch_size * tIndex:batch_size * tIndex + batch_size]
x_fixed = np.reshape(x_fixed, (-1, 28 * 28))
reco,dropoutSamples = sess.run([y,dropout_samples], feed_dict={x_hat: x_fixed, x: x_fixed, keep_prob: 1.0})
reco = np.reshape(reco, (-1, 28, 28))
x_fixed = np.reshape(x_fixed, (-1, 28, 28))
ims("results/" + "MNIST__Real_Bernoulli" + str(0) + ".png", merge(x_fixed[:64], [8, 8]))
ims("results/" + "MNIST__Reco_Bernoulli" + str(0) + ".png", merge(reco[:64], [8, 8]))
# yy = sess.run(y,feed_dict={x_hat: x_fixed, x: x_fixed, keep_prob: 1.0})
# yy = np.reshape(yy,(-1,28,28))
# ims("results/" + "VAE" + str(0) + ".jpg", merge(yy[:64], [8, 8]))
z_in1 = tf.placeholder(tf.float32, shape=[None, dim_z])
z_in2 = tf.placeholder(tf.float32, shape=[None, dim_z])
z_in3 = tf.placeholder(tf.float32, shape=[None, dim_z])
z_in4 = tf.placeholder(tf.float32, shape=[None, dim_z])
z_in5 = tf.placeholder(tf.float32, shape=[None, dim_z])
z_in6 = tf.placeholder(tf.float32, shape=[None, dim_z])
mix_in = tf.placeholder(tf.float32, shape=[None, 6])
x_in1 = tf.placeholder(tf.float32, shape=[None, 28 * 28])
y4 = sess.run(yy, feed_dict={z_in2: z_samples, keep_prob: 0.9})
z_samples = z1_samples + z2_samples + z3_samples + z4_samples
y5 = sess.run(yy, feed_dict={z_in2: z_samples, keep_prob: 0.9})
yyArr = np.zeros((batch_size, 28 * 28))
yyArr[0:10, :] = x_fixed[0:10]
yyArr[10:20, :] = y1[0:10]
yyArr[20:30, :] = y2[0:10]
yyArr[30:40, :] = y3[0:10]
yyArr[40:50, :] = y4[0:10]
yyArr[50:60, :] = y5[0:10]
yyArr = np.reshape(yyArr, (-1, 28, 28))
ims("results/" + "VAE" + str(0) + ".jpg", merge(yyArr[:60], [6, 10]))
bc = 0
else:
lastvalue = np.ones((10))
valid_reco = Give_Reconstruction(x_hat, x)
x_valid = x_test[0:batch_size]
x_valid = np.reshape(x_valid, (-1, 28 * 28))
bestScore = 100000
n_epochs = 100
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
json_file.close()
loaded_model = model_from_json(loaded_model_json)
weight = 'gen.h5'
loaded_model.load_weights(weight)
Hash = sys.argv[1]
stat2 = sys.argv[2]
if stat2[-1] == '/':
pass
else:
stat2 = stat2 + '/'
# Файлы .tsv
if Hash[-4:] == '.tsv':
A = pandas.read_csv(Hash, header=None)
for i in range(len(A)):
ims(stat2 + str(A[0][i]) + '.png', hash_to_im(A[0][i][4:-8]))
# Файлы .txt
if Hash[-4:] == '.txt':
f = open(Hash)
b = f.read().split('\n')
f.close()
for i in range(len(b)):
if len(b[i]) == 52:
ims(stat2 + b[i] + '.png', hash_to_im(str(b[i])[4:-8]))
# Hash
else:
ims(stat2 + Hash + '.png', hash_to_im(Hash[4:-8]))
def train(self):
batchsize = 100
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
start_time = time.time()
for epoch in range(501):
for idx in range(int(self.n_samples / batchsize)):
batch = self.mnist.unbalance01.next_batch(batchsize)[0]
_, gen_loss, lat_loss = sess.run(
(self.optimizer, self.generation_loss,
self.latent_loss),
feed_dict={
self.images: batch,
self.batchsize: batchsize
})
# print("epoch {}: genloss {} latloss{}".format(epoch, np.mean(gen_loss), np.mean(lat_loss)))
if idx == range(int(self.n_samples /
batchsize))[-1] and epoch % 50 == 0:
end_time = time.time()
print(
"Training epoch {}: --- {} seconds --- genloss {} latloss{}"
.format(epoch, end_time - start_time,
np.mean(gen_loss), np.mean(lat_loss)))
# plt.scatter(latent_var[class0_idx,0],latent_var[class0_idx,1],c='red', s=1)
# plt.scatter(latent_var[class1_idx,0],latent_var[class1_idx,1],c='blue', s=1)
# plt.savefig('latent_plots/unbalance01_epoch{}_{}.png'.format(epoch, idx))
# plt.close()
# ratio: 10:1
num_random_samples = 900
im_w, im_h = 30, 30
r = np.random.RandomState(1234)
randoms = np.array([
r.normal(0, 1, 20)
for _ in range(num_random_samples)
],
dtype=np.float32)
random_samples = np.zeros((1, 28, 28))
for i in range(num_random_samples // 100):
generated_test = sess.run(
self.generated_images,
feed_dict={
self.guessed_z:
randoms[i * 100:(i + 1) * 100],
self.batchsize: batchsize
})
generated_test = generated_test.reshape(
batchsize, 28, 28)
random_samples = np.concatenate(
(random_samples, generated_test), axis=0)
random_samples = random_samples[1:]
if epoch == 500:
ims("results/vae_10to1.jpg",
merge(random_samples, [im_w, im_h]))
# if epoch == 500:
# for i, image in enumerate(random_samples):
# ims('results_random_samples/random01_epoch500_10to1/temp{}.jpg'.format(i), image)
# # ratio: 100:1
# num_random_samples = 10000
# im_w, im_h = 100, 100
# r = np.random.RandomState(1234)
# randoms = np.array([r.normal(0, 1, 20) for _ in range(num_random_samples)], dtype = np.float32)
# random_samples = np.zeros((1,28,28))
# for i in range(num_random_samples//100):
# generated_test = sess.run(self.generated_images, feed_dict={self.guessed_z: randoms[i*100:(i+1)*100], self.batchsize: batchsize})
# generated_test = generated_test.reshape(batchsize,28,28)
# random_samples = np.concatenate((random_samples, generated_test), axis=0)
# random_samples = random_samples[1:]
# if epoch == 500:
# ims("results/random01_epoch500_100to1/all_images.jpg",merge(random_samples,[im_w, im_h]))
# # if epoch == 500:
# # for i, image in enumerate(random_samples):
# # ims('results_random_samples/random_epoch500_100to1/temp{}.jpg'.format(i), image)
# ratio: 1000:1
# num_random_samples = 96100
# im_w, im_h = 310, 310
# r = np.random.RandomState(1234)
# randoms = np.array([r.normal(0, 1, 20) for _ in range(num_random_samples)], dtype = np.float32)
# random_samples = np.zeros((1,28,28))
# for i in range(num_random_samples//100):
# st()
# generated_test = sess.run(self.generated_images, feed_dict={self.guessed_z: randoms[i*100:(i+1)*100], self.batchsize: batchsize})
# generated_test = generated_test.reshape(batchsize,28,28)
# random_samples = np.concatenate((random_samples, generated_test), axis=0)
# random_samples = random_samples[1:]
# if epoch == 500:
# ims("results/random01_epoch500_1000to1/all_images.jpg",merge(random_samples,[im_w, im_h]))
# # if epoch == 500:
# # for i, image in enumerate(random_samples):
# # ims('results_random_samples/random_epoch500_100to1/temp{}.jpg'.format(i), image)
start_time = time.time()
_, 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: 1.0
})
print(
"epoch %d: L_tot %03.2f L_likelihood %03.2f L_divergence %03.2f"
% (epoch, tot_loss, loss_likelihood, loss_divergence))
# print cost every epoch
y_PRR = sess.run(y, feed_dict={x_hat: x_fixed, keep_prob: 1})
y_RPR = np.reshape(y_PRR, (-1, 64, 64, 3))
ims("results/" + "VAE" + str(epoch) + ".jpg",
merge2(y_RPR[:64], [8, 8]))
loss_likelihood = loss_likelihood * -1
if bestScore > loss_likelihood:
bestScore = loss_likelihood
saver.save(sess, "models/Dropout_Simple_Celeba4_Bernoulli")
if epoch > 0:
x_fixed_image = np.reshape(x_fixed, (-1, 64, 64, 3))
ims("results/" + "Real" + str(epoch) + ".jpg",
merge2(x_fixed_image[:64], [8, 8]))
# saver.save(sess, "F:/Third_Experiment/Dropout_Simple_Celeba4")
batch_labels = np.random.multinomial(1,
discrete_len * [float(1.0 / discrete_len)],
size=[batch_size])
myArr = []
for k in range(10):
batch_labels = np.zeros((batch_size, discrete_len))
batch_codes = np.concatenate((batch_labels, np.random.uniform(-1, 1, size=(batch_size, continous_len))),
axis=1)
batch_labels[:, k] = 1
batch_z = np.random.uniform(-1, 1, [batch_size, noise_len]).astype(np.float32)
y_PRR = sess.run(Generated_Imags, feed_dict={x_hat: batch_images, z_in: batch_z, y_in: batch_codes})
y_RPR = np.reshape(y_PRR, (-1, 32, 32, 3))
ims("results/" + "myh" + str(0) + ".png", merge2(y_RPR, [8, 8]))
for k1 in range(8):
myArr.append(y_RPR[k1])
myArr = np.array(myArr)
ims("results/" + "myh" + str(0) + ".png", merge2(myArr, [10, 8]))
ims("results/" + "real" + str(0) + ".png", merge2(batch_images, [8, 8]))
b1 = 0
b = 0
b = 0
else:
batch_images = x_train[0:batch_size]
"""Directory where to write event logs """
"""and checkpoint.""")
tf.app.flags.DEFINE_integer('max_steps', 5000,
"""Number of batches to run.""")
tf.app.flags.DEFINE_boolean('log_device_placement', False,
"""Whether to log device placement.""")
INITIAL_LEARNING_RATE = 0.01
NUM_CLASSES = 10
FT_DIM = 3
CODE_LEN = 20
imHeight = 28
imWidth = 28
numCh = 1
# Get images and labels
images_tr, labels_tr = mnistip.distorted_inputs(randFlip=True)
init = tf.initialize_all_variables()
sess = tf.InteractiveSession()
sess.run(init)
tf.train.start_queue_runners(sess=sess)
_images, _labels = sess.run([images_tr, labels_tr])
reshaped_vis = np.squeeze(_images)
ims("results/base.jpg",merge(reshaped_vis[:64],[8,8]))
print(_images.shape)
def build_model():
""" Graph Input """
IMG = tf.placeholder(tf.float32, [None, 10000], name='real_img')
IMG_matrix = tf.reshape(IMG, [-1, 100, 100, 1], name='img_matrix')
ZN = tf.placeholder(tf.float32, [None, 100], name='noise')
'''train data'''
imgpath = './newtrain1/'
img_arr, lab_arr = GetFlatPix(imgpath) # (17750,10000),(17750,15)
n_train = img_arr.shape[0]
""" Loss Function """
G_sample = generator(ZN, is_training=True, reuse=False) #
# print(G_sample)#outputs = tf.convert_to_tensor(inputs)
D_real_out, D_real_pred = discriminator(IMG_matrix,
is_training=True,
reuse=False)
D_fake_out, D_fake_pred = discriminator(G_sample,
is_training=True,
reuse=True)
# get loss for discriminator(这里用的是sigmoid function)
d_loss_real = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=D_real_out, labels=tf.ones_like(D_real_out)))
d_loss_fake = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=D_fake_out, labels=tf.zeros_like(D_fake_out)))
d_loss = d_loss_real + d_loss_fake
# get loss for generator
g_loss = tf.reduce_mean(
tf.nn.sigmoid_cross_entropy_with_logits(
logits=D_fake_out, labels=tf.ones_like(D_fake_out)))
""" Training """
# ——————————————————方式1——————————————————————————————————————————
# # 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 'dis_' in var.name]
# g_vars = [var for var in t_vars if 'gen_' in var.name]
#
# # optimizers
# with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
# d_optimizer = tf.train.AdamOptimizer(1e-3, beta1=0.5) \
# .minimize(d_loss, var_list=d_vars)
# g_optimizer = tf.train.AdamOptimizer(1e-3, beta1=0.5) \
# .minimize(g_loss, var_list=g_vars)
# ————————————————————————————————————————————————————————————————————
# ————————————————————————方式2————————————————————————————————————————
gen_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='generator')
dis_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope='discriminator')
gen_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS,
scope='generator')
with tf.control_dependencies(gen_update_ops):
train_gen = tf.train.AdamOptimizer(1e-3, beta1=0.5).minimize(
g_loss, var_list=gen_vars)
dis_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS,
scope='discriminator')
with tf.control_dependencies(dis_update_ops):
train_dis = tf.train.AdamOptimizer(1e-3, beta1=0.5).minimize(
d_loss, var_list=dis_vars)
# """" Testing """
# # for test
# fake_images = generator(ZN, is_training=False, reuse=True)#测试用
""" 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", d_loss)
g_loss_sum = tf.summary.scalar("g_loss", g_loss)
# final summary operations
g_sum = tf.summary.merge([d_loss_fake_sum, g_loss_sum])
d_sum = tf.summary.merge([d_loss_real_sum, d_loss_sum])
# ——————————————————start train————————————————————————————————
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# saver to save model
saver = tf.train.Saver()
# summary writer
writer = tf.summary.FileWriter(logdir=LOGS_DIRECTORY,
graph=sess.graph) # ——————————改
if not os.path.exists('result_DCGAN/'):
os.makedirs('result_DCGAN/')
'''loop for train'''
start_time = time.time()
for step in range(200000):
start = (step * batch_size) % n_train
end = min(start + batch_size, n_train)
img_batch = img_arr[start:end]
# generator noise to feed to the generator
noise_batch = np.random.uniform(-1, 1,
[batch_size, z_dim]).astype(np.float32)
# (1)先固定G开始Train D,D要看来自样本的img和来自generator的img
_, summary_str, dl = sess.run([train_dis, d_sum, d_loss],
feed_dict={
IMG: img_batch,
ZN: noise_batch
})
writer.add_summary(summary_str, step)
# (2)固定D，train G（G只需要feed noise即可）
_, summary_str, gl = sess.run([train_gen, g_sum, g_loss],
feed_dict={ZN: noise_batch})
writer.add_summary(summary_str, step)
if step % 1000 == 0:
print('step:%d,discriminator_loss:%f,generator_loss:%f' %
(step, dl, gl))
"""" Testing """
fake_images = generator(ZN, is_training=False, reuse=True) # 测试用
final_samples = sess.run(fake_images, feed_dict={ZN: noise_batch})
final_samples = np.reshape(final_samples, (-1, 100, 100, 1))
from scipy.misc import imsave as ims
# 显示生成的图片
ims("./result_DCGAN/" + str(step) + ".jpg",
merge(final_samples[0:batch_size], [8, 8]))
# save model for final step
save_path = saver.save(sess, MODEL_DIRECTORY)
print("Model saved in file: %s" % save_path)
def train():
X_p = tf.placeholder(tf.float32, [None, img_dim])
# kp=tf.placeholder(tf.float32)
# encoding(img(x_hat)=>encoder=>mean,variance)
mu, sigma = gaussian_MLP_encoder(X_p, 512, 100, keep_prob=0.5)
# sampling by re-parameterization technique
eps = tf.random_normal(tf.shape(mu), 0, 1, dtype=tf.float32)
z_composed = mu + tf.exp(sigma / 2) * eps
# decoding(compose_z=>decoder=>img'(y)) #x is real img
y = bernoulli_MLP_decoder(z_composed, 512, 10000,
keep_prob=0.5) #sigmoid出来的y
y = tf.clip_by_value(y, 1e-8, 1 - 1e-8) #avoid loss NAN
# loss
recon_loss = -tf.reduce_sum(X_p * tf.log(y) + (1 - X_p) * tf.log(1 - y), 1)
kl_loss = 0.5 * tf.reduce_sum(
tf.square(mu) + tf.square(sigma) - tf.log(1e-8 + tf.square(sigma)) - 1,
1)
recon_loss = tf.reduce_mean(recon_loss)
kl_loss = tf.reduce_mean(kl_loss)
loss_op = recon_loss + kl_loss
#optimizer
train_op = tf.train.AdamOptimizer().minimize(loss_op)
#start session
sess = tf.Session()
sess.run(tf.global_variables_initializer())
if not os.path.exists('mlp_result/'):
os.makedirs('mlp_result/')
for step in range(100000):
start = (step * batch_size) % n_train
end = min(start + batch_size, n_train)
_, total_loss, RE_loss, KL_loss = sess.run(
[train_op, loss_op, recon_loss, kl_loss],
feed_dict={X_p: img_arr[start:end]})
if step % 1000 == 0: # train
print('step:%d,Total_Loss:%f,RE_loss:%f,KL_loss:%f' %
(step, total_loss, RE_loss, KL_loss))
# test
"""" Testing """
# # Sampling from random z 训练好了之后，把decoder单独拿出来，把z丢给他
ZN = tf.placeholder(tf.float32, [None, n_latent])
fake_images = decoder(ZN, 10000, 512)
z_batch = np.random.normal(0., 1, (batch_size, n_latent)).astype(
np.float32)
samples = sess.run(fake_images, feed_dict={ZN: z_batch})
samples_img = np.reshape(samples, (-1, 100, 100, 1))
from scipy.misc import imsave as ims
# 显示生成的图片
ims("./mlp_result/" + str(step) + ".jpg",
merge(samples_img[0:batch_size], [8, 8]))
loaded_model = model_from_json(loaded_model_json)
weight='gen.h5'
loaded_model.load_weights(weight)
Hash=sys.argv[1]
stat2=sys.argv[2]
if stat2[-1]=='/':
pass
else:
stat2=stat2+'/'
# Файлы .tsv
if Hash[-4:]=='.tsv':
A=pandas.read_csv(Hash,header=None)
for i in range(len(A)):
ims(stat2+str(A[0][i])+'.png',hash_to_im(A[0][i][4:-8]))
# Файлы .txt
if Hash[-4:]=='.txt':
f = open(Hash)
b=f.read().split('\n')
f.close()
for i in range(len(b)):
if len(b[i])==52:
ims(stat2+b[i]+'.png',hash_to_im(str(b[i])[4:-8]))
# Hash
else:
ims(stat2+Hash+'.png',hash_to_im(Hash[4:-8]))
)
a4 = mpimg.imread(
'F:/Third_Experiment/NewExperiment/InfoVAE/results/myselection/InfoVAE_womanToMan3.png'
)
a5 = mpimg.imread(
'F:/Third_Experiment/NewExperiment/InfoVAE/results/myselection/InfoVAE_womanToMan4.png'
)
myImage = np.zeros((5 * 64, 10 * 64, 3))
myImage[0:64, 0:64 * 10, 0:3] = a1
myImage[64:64 * 2, 0:64 * 10, 0:3] = a2
myImage[64 * 2:64 * 3, 0:64 * 10, 0:3] = a3
myImage[64 * 3:64 * 4, 0:64 * 10, 0:3] = a4
myImage[64 * 4:64 * 5, 0:64 * 10, 0:3] = a5
ims("results/" + "InfoVAE_Emotion" + str(00) + ".png", myImage)
bc = 0
# load dataset
# load dataset
file_dir = "C:/commonData/rendered_chairs/rendered_chairs/"
files = file_name(file_dir)
data_files = files
data_files = sorted(data_files)
data_files = np.array(data_files) # for tl.iterate.minibatches
n_examples = np.shape(data_files)[0]
# load dataset
count1 = 0
image_size = 64
