def main():
mnist = input_data.read_data_sets('../data/MNIST_data', one_hot=True)
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# GAN Model
model = cgan.CGAN(s, is_train=False)
s.run(tf.global_variables_initializer())
saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
saver.restore(s, os.path.join('./model/', ckpt_name))
else:
print("Cannot restore checkpoint!")
return False
sample_z = np.random.uniform(
-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
# Create conditional one-hot vector, with index 5 = 1
sample_y = np.zeros(shape=[model.sample_num, model.y_dim])
sample_y[:, 5] = 1
sample_x, _ = mnist.train.next_batch(model.sample_num)
sample_x = np.reshape(
sample_x,
[-1, model.input_height, model.input_width, model.channel])
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: sample_z,
model.y: sample_y
})
samples = np.reshape(
samples,
[-1, model.output_height, model.output_width, model.channel])
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'test.png'
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Close tf.Session
s.close()
def after_run(self, run_context, run_values):
_ = run_context
if self._should_trigger:
self._timer.update_last_triggered_step(self._iter_count)
# Save sample images, visualizing the current training results
save_images(
self.img_path + '_%02d_%04d.jpg' %
(self.model.epoch_id, self.model.batch_id),
run_values.results['sample_img'], self.grid_size)
# save_images(self.img_path+'_%02d_%04d_out.jpg' % (self.model.epoch_id, self.model.batch_id),
# run_values.results['g_out'],
# self.grid_size)
## For checking. Save groundtruth (natuarl) training images.
# save_images(self.img_path+'_%02d_%04d_gt.jpg' % (self.model.epoch_id, self.model.batch_id),
# run_values.results['gt_img'][:64],
# self.grid_size)
self._iter_count += 1
def main():
start_time = time.time() # Clocking start
mnist = input_data.read_data_sets('../data/MNIST_data', one_hot=True)
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# GAN Model
model = gan.GAN(s)
sample_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
sample_x, _ = mnist.train.next_batch(model.sample_num)
samples = s.run(model.g,feed_dict={model.x: sample_x,model.z: sample_z,})
samples = np.reshape(samples, [-1, model.output_height, model.output_width, model.channel])
# Summary saver
model.writer.add_summary(summary, step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'test_{:08d}.png'.format(step)
# Generated image save
iu.save_images(samples,size=[sample_image_height, sample_image_width],image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step=step)
# Close tf.Session
s.close()
def __call__(self, save_path):
"""
...
"""
if not os.path.exists(save_path):
os.makedirs(save_path)
time_consumed_total = 0.
for epoch in range(1, self.epochs + 1):
start = time.time()
total_gen_loss = 0
total_disc_loss = 0
for daily_parking_rate, condition in self.monthly_parking_rate:
gen_loss, disc_loss = self.train_step(daily_parking_rate,
condition)
total_gen_loss += gen_loss
total_disc_loss += disc_loss
time_consumed = time.time() - start
time_consumed_total += time_consumed
time_consumed_agv = time_consumed_total / epoch
self.epochs_last = self.epochs - epoch
estimate_time_last = self.epochs_last * time_consumed_agv
print(
'Time for epoch {}/{} is {} sec - gen_loss = {}, disc_loss = {}, time estimated to finish: {}'
.format(epoch, self.epochs,
time.time() - start, total_gen_loss / batch_size,
total_disc_loss / batch_size, estimate_time_last))
if epoch % save_interval == 0:
save_images(save_path, epoch, self.generator, self.seed,
self.avg_weekend, self.avg_workday)
if epoch > 150:
self.generate(save_path, epoch)
self.save_model(save_path, time_consumed_total)
self.save_model(save_path, time_consumed_total)
def main():
start_time = time.time() # Clocking start
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# pre-chosen
attr_labels = [
'Big_Nose', 'Black_Hair', 'Blond_Hair', 'Blurry', 'Brown_Hair',
'Bushy_Eyebrows', 'Chubby', 'Double_Chin', 'Eyeglasses',
'Gray_Hair'
]
# StarGAN Model
model = stargan.StarGAN(s, attr_labels=attr_labels) # StarGAN
# Initializing
s.run(tf.global_variables_initializer())
# loading CelebA DataSet
ds = DataSet(
height=64,
width=64,
channel=3,
ds_image_path="D:/DataSet/CelebA/CelebA-64.h5",
ds_label_path="D:/DataSet/CelebA/Anno/list_attr_celeba.txt",
# ds_image_path="D:/DataSet/CelebA/Img/img_align_celeba/",
ds_type="CelebA",
use_save=False,
save_file_name="D:/DataSet/CelebA/CelebA-64.h5",
save_type="to_h5",
use_img_scale=False,
img_scale="-1,1")
# x_A # Celeb-A
img_a = np.reshape(ds.images, [-1, 64, 64, 3])
attr_a = ds.labels
# x_B # Celeb-A # copied from x_A
# later it'll be replaced to another DataSet like RaFD, used in the paper
# but i can't find proper(good) DataSets, so i just do with single-domain (Celeb-A)
# img_b = img_a[:]
# attr_b = attr_a[:]
# ds_a_iter = DataIterator(img_a, attr_a, train_step['batch_size'])
# ds_b_iter = DataIterator(img_b, attr_b, train_step['batch_size'])
print("[+] pre-processing elapsed time : {:.8f}s".format(time.time() -
start_time))
print("[*] image_A :", img_a.shape, " attribute A :", attr_a.shape)
global_step = 0
for epoch in range(train_step['epoch']):
# learning rate decay
lr_decay = 1.
if epoch >= train_step['epoch']:
lr_decay = (train_step['epoch'] -
epoch) / (train_step['epoch'] / 2.)
# re-implement DataIterator for multi-input
pointer = 0
for i in range(ds.num_images // train_step['batch_size']):
start = pointer
pointer += train_step['batch_size']
if pointer > ds.num_images: # if ended 1 epoch
# Shuffle training DataSet
perm = np.arange(ds.num_images)
np.random.shuffle(perm)
# To-Do
# Getting Proper DataSet
img_a, img_b = img_a[perm], img_a[perm]
attr_a, attr_b = attr_a[perm], attr_a[perm]
start = 0
pointer = train_step['batch_size']
end = pointer
x_a, y_a = img_a[start:end], attr_a[start:end][:]
x_b, y_b = img_a[start:end], attr_a[start:end][:]
x_a = iu.transform(x_a, inv_type='127')
x_b = iu.transform(x_b, inv_type='127')
batch_a = ds.concat_data(x_a, y_a)
batch_b = ds.concat_data(x_b, y_b)
eps = np.random.rand(train_step['batch_size'], 1, 1, 1)
# Generate fake_B
fake_b = s.run(model.fake_B, feed_dict={model.x_A: batch_a})
# Update D network - 5 times
for _ in range(5):
_, d_loss = s.run(
[model.d_op, model.d_loss],
feed_dict={
model.x_B: batch_b,
model.y_B: y_b,
model.fake_x_B: fake_b,
model.lr_decay: lr_decay,
model.epsilon: eps,
})
# Update G network - 1 time
_, g_loss = s.run(
[model.g_op, model.g_loss],
feed_dict={
model.x_A: batch_a,
model.x_B: batch_b,
model.y_B: y_b,
model.lr_decay: lr_decay,
model.epsilon: eps,
})
if global_step % train_step['logging_step'] == 0:
eps = np.random.rand(train_step['batch_size'], 1, 1, 1)
# Summary
samples, d_loss, g_loss, summary = s.run(
[
model.fake_A, model.d_loss, model.g_loss,
model.merged
],
feed_dict={
model.x_A: batch_a,
model.x_B: batch_b,
model.y_B: y_b,
model.fake_x_B: fake_b,
model.lr_decay: lr_decay,
model.epsilon: eps,
})
# Print loss
print("[+] Epoch %04d Step %07d =>" % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Summary saver
model.writer.add_summary(summary, epoch)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}_{1}.png'.format(
epoch, global_step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# MNIST Dataset load
#mnist = DataSet(ds_path="D:/DataSet/mnist/").data
# Loading Cifar-10 DataSet
ds = DataSet2(
height=32,
width=32,
channel=3,
ds_path=
"/media/shar/240A27640A2731EA/shared2/Awesome-GANs-master/BGAN/cifar/",
ds_name='cifar-10')
ds_iter = DataIterator(
x=iu.transform(ds.train_images, '127'),
y=ds.train_labels,
batch_size=train_step['batch_size'],
label_off=True
) # using label # maybe someday, i'll change this param's name
# Generated image save
test_images = iu.transform(ds.test_images[:100], inv_type='127')
iu.save_images(test_images,
size=[10, 10],
image_path=results['output'] + 'sample.png',
inv_type='127')
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# BGAN Model
model = bgan.BGAN(s)
# Initializing
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
d_loss = 0.
d_overpowered = False
global_step = saved_global_step
start_epoch = global_step // (len(ds.train_images) // model.batch_size
) # recover n_epoch
ds_iter.pointer = saved_global_step % (
len(ds.train_images) // model.batch_size) # recover n_iter
for epoch in range(start_epoch, train_step['epochs']):
#batch_x, _ = mnist.train.next_batch(model.batch_size)
batch_x, _ = ds_iter.next_batch()
batch_x = batch_x.reshape(-1, model.n_input)
batch_z = np.random.uniform(
-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
if not d_overpowered:
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
d_overpowered = d_loss < g_loss / 2.
# Logging
if global_step % train_step['logging_interval'] == 0:
batch_x, _ = ds_iter.next_batch()
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print("[+] Step %08d => " % global_step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g, feed_dict={
model.z: sample_z,
})
samples = np.reshape(samples, [-1] + model.image_shape[1:])
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_1{:08d}.png'.format(
global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step=global_step)
print(sample_dir)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # clocking start
gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.95)
config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_options)
with tf.Session(config=config) as s:
end_time = time.time() - start_time
# BEGAN Model
model = began.BEGAN(s)
# initializing
s.run(tf.global_variables_initializer())
# load model & graph & weight
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
print("[+] global step : %s" % global_step, " successfully loaded")
else:
global_step = 0
print('[-] No checkpoint file found')
# return
# initializing variables
tf.global_variables_initializer().run()
# loading Celeb-A dataset
ds = DataSet(input_height=64,
input_width=64,
input_channel=3,
dataset_name="celeb-a")
images = ds.images
sample_z = np.random.uniform(-1.,
1.,
size=(model.sample_num,
model.z_dim)).astype(np.float32)
d_overpowered = False
kt = tf.Variable(0., dtype=tf.float32) # init K_0 value, 0
batch_per_epoch = int(len(images) / paras['batch_size'])
for epoch in range(paras['epoch']):
for step in range(batch_per_epoch):
iter_ = datasets.DataIterator([images], paras['batch_size'])
# k_t update
# k_t+1 = K_t + lambda_k * (gamma * d_real - d_fake)
kt = kt + model.lambda_k * (model.gamma * model.D_real -
model.D_fake)
# z update
batch_z = np.random.uniform(
-1., 1.,
[paras['batch_size'], model.z_dim]).astype(np.float32)
# update D network
if not d_overpowered:
s.run(model.d_op,
feed_dict={
model.x: 0,
model.z: batch_z,
model.kt: kt
})
# update G network
s.run(model.g_op, feed_dict={model.z: batch_z, model.kt: kt})
if global_step % paras['logging_interval'] == 0:
batch_z = np.random.uniform(
-1., 1.,
[paras['batch_size'], model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: 0,
model.z: batch_z
})
# print loss
print("[+] Epoch %03d Step %05d => " % (epoch, step),
"D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# update overpowered
d_overpowered = d_loss < g_loss / 3
# training G model with sample image and noise
samples = s.run(model.G,
feed_dict={
model.x: 0,
model.z: sample_z
})
# summary saver
model.writer.add_summary(summary, step)
# export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = dirs[
'sample_output'] + 'train_{0}_{1}.png'.format(
epoch, step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# model save
model.saver.save(s, dirs['model'], global_step=step)
global_step += 1
# elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# Loading MNIST DataSet
mnist = DataSet(ds_path="D:\\DataSet/mnist/").data
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
idx = 1
divergences = ['GAN', 'KL', 'Reverse-KL', 'JS',
'JS-Weighted', 'Squared-Hellinger', 'Pearson', 'Neyman',
'Jeffrey', 'Total-Variation']
assert (0 <= idx < len(divergences))
results['output'] += '%s/' % divergences[idx]
results['model'] += '%s/fGAN-model.ckpt' % divergences[idx]
with tf.Session(config=config) as s:
# f-GAN model
model = fgan.FGAN(s, batch_size=train_step['batch_size'],
divergence_method=divergences[idx],
use_tricky_g_loss=True)
# Initializing variables
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/%s/' % divergences[idx])
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step, " successfully loaded")
else:
print('[-] No checkpoint file found')
for global_step in range(saved_global_step, train_step['global_steps']):
batch_x, _ = mnist.train.next_batch(model.batch_size)
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
if global_step % train_step['logging_interval'] == 0:
summary = s.run(model.merged,
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print("[+] Global step %06d => " % global_step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim])
samples = s.run(model.g,
feed_dict={
model.z: sample_z,
})
samples = np.reshape(samples, (-1, 28, 28, 1))
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}.png'.format(global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='255')
# Model save
model.saver.save(s, results['model'], global_step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# MNIST Dataset load
mnist = input_data.read_data_sets('../data/MNIST_data', one_hot=True)
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# InfoGAN Model
model = infogan.InfoGAN(s)
# Initializing
s.run(tf.global_variables_initializer())
sample_x, _ = mnist.test.next_batch(model.sample_num)
sample_x = np.reshape(sample_x, [-1] + model.image_shape[1:])
#sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
z = np.random.uniform(-1., 1., model.z_dim).astype(np.float32)
sample_z = [z] * model.sample_num
sample_c = np.zeros(
shape=[model.sample_num, model.n_cat + model.n_cont])
samples_cont = np.random.normal(loc=0.0,
scale=1.0,
size=model.sample_num)
samples_cont = np.sort(samples_cont)
k = 0
sc = 2
for j in range(model.sample_num):
sample_c[j][k] = 1
sample_c[j][11] = samples_cont[j] * sc
k += 1
if k == 10:
k = 0
d_overpowered = False
for step in range(train_step['global_step']):
batch_x, _ = mnist.train.next_batch(model.batch_size)
batch_x = np.reshape(batch_x, [-1] + model.image_shape[1:])
batch_x = batch_x * 2 - 1
batch_z = np.random.uniform(
-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
batch_cat = np.random.multinomial(1,
model.n_cat *
[1.0 / model.n_cat],
size=model.batch_size)
mean = np.zeros(shape=[model.batch_size, model.n_cont])
stddev = np.ones(shape=[model.batch_size, model.n_cont])
epsilon = np.random.normal(loc=0.0,
scale=1.0,
size=[model.batch_size, model.n_cont])
batch_cont = mean + epsilon * stddev
batch_c = np.concatenate((batch_cat, batch_cont), axis=1)
# Update D network
if not d_overpowered:
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c,
})
_, q_loss = s.run([model.q_op, model.q_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c
})
d_overpowered = d_loss < g_loss / 2
# Logging
if step % train_step['logging_interval'] == 0:
batch_x, _ = mnist.test.next_batch(model.batch_size)
batch_x = np.reshape(batch_x, [-1] + model.image_shape[1:])
batch_x = batch_x * 2 - 1
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
batch_cat = np.random.multinomial(1,
model.n_cat *
[1.0 / model.n_cat],
size=model.batch_size)
mean = np.zeros(shape=[model.batch_size, model.n_cont])
stddev = np.ones(shape=[model.batch_size, model.n_cont])
epsilon = np.random.normal(
loc=0.0, scale=1.0, size=[model.batch_size, model.n_cont])
batch_cont = mean + epsilon * stddev
batch_c = np.concatenate((batch_cat, batch_cont), axis=1)
d_loss, g_loss, q_loss, summary = s.run(
[model.d_loss, model.g_loss, model.q_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c,
})
d_overpowered = d_loss < g_loss / 2
# Print loss
print("[+] Step %08d => " % step,
"Dloss: {:.8f}".format(d_loss),
"Gloss: {:.8f}".format(g_loss),
"Qloss: {:.8f}".format(q_loss))
for k in range(0, 10):
sample_feed = [sample_c[k]]
# Training G model with sample image and noise
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: [sample_z[0]],
model.c: sample_feed
})
# Summary saver
model.writer.add_summary(summary, step)
# Export image generated by model G
sample_image_height = 1
sample_image_width = 1
sample_dir = results['output'] + str(
k) + 'train_{:08d}.png'.format(step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Training G model with sample image and noise
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: sample_z,
model.c: sample_c
})
# Summary saver
model.writer.add_summary(summary, step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(
step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step=step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# DCGAN model
model = dcgan.DCGAN(s, batch_size=train_step['batch_size'])
# Load model & Graph & Weights
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
print("[+] global step : %s" % global_step, " successfully loaded")
else:
global_step = 0
print('[-] No checkpoint file found')
# Initializing variables
s.run(tf.global_variables_initializer())
# Training, test data set
dataset = DataSet(input_height=32,
input_width=32,
input_channel=3,
name='cifar-100')
dataset_iter = DataIterator(dataset.train_images, dataset.train_labels,
train_step['batch_size'])
sample_x = dataset.valid_images[:model.sample_num].astype(
np.float32) / 225.
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim])
d_overpowered = False # G loss > D loss * 2
step = int(global_step)
cont = int(step / 750)
for epoch in range(cont, cont + train_step['epoch']):
for batch_images, _ in dataset_iter.iterate():
batch_x = batch_images.astype(np.float32) / 225.
batch_z = np.random.uniform(
-1., 1.,
[train_step['batch_size'], model.z_dim]).astype(np.float32)
# Update D network
if not d_overpowered:
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={model.z: batch_z})
d_overpowered = d_loss < g_loss / 2.
if step % train_step['logging_interval'] == 0:
batch_z = np.random.uniform(
-1., 1.,
[train_step['batch_size'], model.z_dim]).astype(
np.float32)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
d_overpowered = d_loss < g_loss / 2.
# Print loss
print("[+] Epoch %03d Step %05d => " % (epoch, step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: sample_z,
})
# Summary saver
model.writer.add_summary(summary, step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results[
'output'] + 'train_{0}_{1}.png'.format(epoch, step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step=step)
step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
with tf.Session() as sess:
num_epoch = 5
checkpoint_interval = 10
batch_size = 64
image_size = 32
model = LAPGAN(sess, batch_size=batch_size)
dataset = Dataset("cifar10/")
dataset_iter = DataIterator(dataset.train_images, dataset.train_labels, batch_size)
summary_writer = tf.train.SummaryWriter('logs_{0}/'.format(int(time.time())), sess.graph_def)
sess.run(tf.initialize_all_variables())
sample_images = dataset.valid_images[:model.sample_size].astype(np.float32) / 255.0
sample_z = np.random.uniform(-1.0, 1.0, size=(model.sample_size , model.z_dim))
d_overpowered = False
step = 0
for epoch in range(num_epoch):
for batch_images, _ in dataset_iter.iterate():
# I0 = batch_images / 255.0
# I1 = downsample(tf.constant(I0, tf.float32))
# l0 = sess.run(upsample(I1))
# h0 = I0 - l0
# z0 = np.random.uniform(-1.0, 1.0, (batch_size,) + image_size + (1,)).astype(np.float32)
# l0 = np.concatenate([l0, z0], axis=-1)
batch_images = batch_images.astype(np.float32) / 255.0
batch_z = np.random.uniform(-1.0, 1.0, [batch_size, model.z_dim]).astype(np.float32)
# update d network
if not d_overpowered:
sess.run(model.d_optim, feed_dict={ model.x: batch_images, model.z: batch_z })
# update g network
sess.run(model.g_optim, feed_dict={ model.z: batch_z })
if step % checkpoint_interval == 0:
# I0 = dataset.valid_images / 255.0
# I1 = downsample(tf.constant(I0, tf.float32))
# l0 = sess.run(upsample(I1))
# h0 = I0 - l0
# z0 = np.random.uniform(-1.0, 1.0, I0.shape[:-1] + (1,)).astype(np.float32)
# l0 = np.concatenate([l0, z0], axis=-1)
batch_images = dataset.valid_images[:batch_size].astype(np.float32) / 255.0
batch_z = np.random.uniform(-1.0, 1.0, [batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = sess.run([
model.d_loss,
model.g_loss,
model.merged
], feed_dict={
model.x: batch_images,
model.z: batch_z
})
d_overpowered = d_loss < g_loss / 2
samples = sess.run(model.G, feed_dict={
model.x: sample_images,
model.z: sample_z
})
summary_writer.add_summary(summary, step)
save_images(samples, [8, 8], './samples/train_{0}_{1}.png'.format(epoch, step))
print('[{0}, {1}] loss: {2} (D) {3} (G) (d overpowered?: {4})'.format(epoch, step, d_loss, g_loss, d_overpowered))
step += 1
def main():
start_time = time.time() # Clocking start
# MNIST Dataset load
mnist = DataSet(ds_path="D:/DataSet/mnist/").data
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# GAN Model
model = gan.GAN(s)
# Initializing
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %s" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
d_loss = 0.
d_overpowered = False
for global_step in range(saved_global_step, train_step['global_step']):
batch_x, _ = mnist.train.next_batch(model.batch_size)
batch_x = batch_x.reshape(-1, model.n_input)
batch_z = np.random.uniform(-1.,
1.,
size=[model.batch_size,
model.z_dim]).astype(np.float32)
# Update D network
if not d_overpowered:
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
d_overpowered = d_loss < (g_loss / 2.)
if global_step % train_step['logging_interval'] == 0:
batch_x, _ = mnist.test.next_batch(model.batch_size)
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
d_overpowered = d_loss < (g_loss / 2.)
# Print loss
print("[+] Step %08d => " % global_step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g, feed_dict={
model.z: sample_z,
})
samples = np.reshape(
samples, [-1, model.height, model.width, model.channel])
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(
global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(
end_time)) # took about 370s on my machine
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
height, width, channel = 128, 128, 3
# loading CelebA DataSet # from 'raw images' or 'h5'
use_h5 = True
if not use_h5:
ds = DataSet(
height=height,
width=height,
channel=channel,
# ds_image_path="D:\\DataSet/CelebA/CelebA-%d.h5" % height,
ds_label_path=os.path.join(cfg.celeba,
"Anno/list_attr_celeba.txt"),
ds_image_path=os.path.join(cfg.celeba, "Img/img_align_celeba/"),
ds_type="CelebA",
use_save=True,
save_file_name=os.path.join(cfg.celeba, "CelebA-%d.h5" % height),
save_type="to_h5",
use_img_scale=False,
)
else:
ds = DataSet(
height=height,
width=height,
channel=channel,
ds_image_path=os.path.join(cfg.celeba, "CelebA-%d.h5" % height),
ds_label_path=os.path.join(cfg.celeba,
"Anno/list_attr_celeba.txt"),
# ds_image_path=os.path.join(cfg.celeba, "Img/img_align_celeba/"),
ds_type="CelebA",
use_save=False,
# save_file_name=os.path.join(cfg.celeba, "CelebA-%d.h5" % height),
# save_type="to_h5",
use_img_scale=False,
)
num_images = ds.num_images
# saving sample images
test_images = np.reshape(iu.transform(ds.images[:16], inv_type='127'),
(16, height, width, channel))
iu.save_images(test_images,
size=[4, 4],
image_path=os.path.join(cfg.output, "sample.png"),
inv_type='127')
ds_iter = DataIterator(x=ds.images,
y=None,
batch_size=train_step['batch_size'],
label_off=True)
del ds
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# SAGAN Model
model = sagan.SAGAN(s,
height=height,
width=width,
channel=channel,
batch_size=train_step['batch_size'],
use_gp=False,
use_hinge_loss=True)
# Initializing
s.run(tf.global_variables_initializer())
print("[*] Reading checkpoints...")
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state(cfg.model_path)
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
global_step = saved_global_step
start_epoch = global_step // (num_images // model.batch_size
) # recover n_epoch
ds_iter.pointer = saved_global_step % (num_images // model.batch_size
) # recover n_iter
for epoch in range(start_epoch, train_step['epochs']):
for batch_x in ds_iter.iterate():
batch_x = iu.transform(batch_x, inv_type='127')
batch_x = np.reshape(batch_x, (model.batch_size, model.height,
model.width, model.channel))
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
if global_step % train_step['logging_interval'] == 0:
summary = s.run(model.merged,
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g_test,
feed_dict={
model.z_test: sample_z,
})
# is_mean, is_std = t.inception_score(iu.inverse_transform(samples, inv_type='127'))
# fid_score = t.fid_score(real_img=batch_x, fake_img=samples[:model.batch_size])
# Print loss
print(
"[+] Epoch %04d Step %08d => " % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss),
# " Inception Score : {:.2f} (±{:.2f})".format(is_mean, is_std),
# " FID Score : {:.2f}".format(fid_score)
)
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = os.path.join(
cfg.output, 'train_{:08d}.png'.format(global_step))
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(
s, os.path.join(cfg.model_path, "SAGAN.ckpt"),
global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# Loading Cifar-10 DataSet
ds = DataSet(height=32,
width=32,
channel=3,
ds_path="D:/DataSet/cifar/cifar-10-batches-py/",
ds_name='cifar-10')
ds_iter = DataIterator(
x=iu.transform(ds.train_images, '127'),
y=ds.train_labels,
batch_size=train_step['batch_size'],
label_off=False
) # using label # maybe someday, i'll change this param's name
# Generated image save
test_images = iu.transform(ds.test_images[:100], inv_type='127')
iu.save_images(test_images,
size=[10, 10],
image_path=results['output'] + 'sample.png',
inv_type='127')
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# ACGAN Model
model = acgan.ACGAN(s,
batch_size=train_step['batch_size'],
n_classes=ds.n_classes)
# Initializing
s.run(tf.global_variables_initializer())
sample_y = np.zeros(shape=[model.sample_num, model.n_classes])
for i in range(10):
sample_y[10 * i:10 * (i + 1), i] = 1
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
global_step = saved_global_step
start_epoch = global_step // (len(ds.train_images) // model.batch_size
) # recover n_epoch
ds_iter.pointer = saved_global_step % (
len(ds.train_images) // model.batch_size) # recover n_iter
for epoch in range(start_epoch, train_step['epochs']):
for batch_x, batch_y in ds_iter.iterate():
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.y: batch_y,
model.z: batch_z,
})
# Update G/C networks
_, g_loss, _, c_loss = s.run(
[model.g_op, model.g_loss, model.c_op, model.c_loss],
feed_dict={
model.x: batch_x,
model.y: batch_y,
model.z: batch_z,
})
if global_step % train_step['logging_interval'] == 0:
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, c_loss, summary = s.run([
model.d_loss, model.g_loss, model.c_loss, model.merged
],
feed_dict={
model.x:
batch_x,
model.y:
batch_y,
model.z:
batch_z,
})
# Print loss
print(
"[+] Epoch %04d Step %08d => " % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss),
" C loss : {:.8f}".format(c_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g,
feed_dict={
model.y: sample_y,
model.z: sample_z,
})
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(
global_step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
model.z: sample_z,
})
samples = np.reshape(samples, [-1] + model.image_shape[1:])
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_1{:08d}.png'.format(global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step=global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
if __name__ == '__main__':
def main():
start_time = time.time() # Clocking start
# MNIST Dataset load
mnist = input_data.read_data_sets('../data/MNIST_data', one_hot=True)
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# GAN Model
model = gan.GAN(s)
# Initializing
s.run(tf.global_variables_initializer())
sample_x, _ = mnist.train.next_batch(model.sample_num)
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
d_overpowered = False
for step in range(train_step['global_step']):
batch_x, _ = mnist.train.next_batch(model.batch_size)
batch_x = batch_x.reshape(-1, model.n_input)
batch_x = batch_x*2 - 1
batch_z = np.random.uniform(-1., 1., size=[model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
if not d_overpowered:
_, d_loss = s.run([model.d_op, model.d_loss], feed_dict={model.x: batch_x,model.z: batch_z,})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],feed_dict={model.x: batch_x,model.z: batch_z,})
d_overpowered = d_loss < (g_loss / 2)
if step % train_step['logging_interval'] == 0:
batch_x, _ = mnist.test.next_batch(model.batch_size)
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run([model.d_loss, model.g_loss, model.merged],
feed_dict={model.x: batch_x,model.z: batch_z,})
d_overpowered = d_loss < (g_loss / 2)
# Print loss
print("[+] Step %08d => " % step," D loss : {:.8f}".format(d_loss)," G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
samples = s.run(model.g,feed_dict={model.x: sample_x,model.z: sample_z,})
samples = np.reshape(samples, [-1, model.output_height, model.output_width, model.channel])
# Summary saver
model.writer.add_summary(summary, step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(step)
# Generated image save
iu.save_images(samples,size=[sample_image_height, sample_image_width],image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step=step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time)) # took about 370s on my machine
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# BEGAN Model
model = began.BEGAN(s) # BEGAN
# Initializing
s.run(tf.global_variables_initializer())
# Celeb-A DataSet images
ds = DataSet(input_height=32,
input_width=32,
input_channel=3,
mode='r').images
dataset_iter = DataIterator(ds, None, train_step['batch_size'],
label_off=True)
sample_x = ds[:model.sample_num]
sample_x = np.reshape(sample_x, [-1] + model.image_shape[1:])
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
# Export real image
valid_image_height = model.sample_size
valid_image_width = model.sample_size
sample_dir = results['output'] + 'valid.png'
# Generated image save
iu.save_images(sample_x, size=[valid_image_height, valid_image_width], image_path=sample_dir)
global_step = 0
for epoch in range(train_step['epoch']):
for batch_images in dataset_iter.iterate():
batch_x = np.reshape(batch_images, [-1] + model.image_shape[1:])
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
})
# Update k_t
_, k, m_global = s.run([model.k_update, model.k, model.m_global],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
if global_step % train_step['logging_step'] == 0:
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Summary
_, k, m_global, d_loss, g_loss, summary = s.run([model.k_update, model.k, model.m_global,
model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print("[+] Epoch %04d Step %07d =>" % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss),
" k : {:.8f}".format(k),
" M : {:.8f}".format(m_global))
# Summary saver
model.writer.add_summary(summary, epoch)
# Training G model with sample image and noise
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: sample_z,
})
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}_{1}.png'.format(epoch, global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step=global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# loading CelebA DataSet
ds = DataSet(
height=64,
width=64,
channel=3,
ds_image_path="/home/zero/hdd/DataSet/CelebA/CelebA-64.h5",
ds_label_path="/home/zero/hdd/DataSet/CelebA/Anno/list_attr_celeba.txt",
# ds_image_path="/home/zero/hdd/DataSet/CelebA/Img/img_align_celeba/",
ds_type="CelebA",
use_save=False,
save_file_name="/home/zero/hdd/DataSet/CelebA/CelebA-64.h5",
save_type="to_h5",
use_img_scale=False,
# img_scale="-1,1"
)
# saving sample images
test_images = np.reshape(iu.transform(ds.images[:16], inv_type='127'),
(16, 64, 64, 3))
iu.save_images(test_images,
size=[4, 4],
image_path=results['output'] + 'sample.png',
inv_type='127')
ds_iter = DataIterator(x=ds.images,
y=None,
batch_size=train_step['batch_size'],
label_off=True)
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# EBGAN Model
model = ebgan.EBGAN(
s, enable_pull_away=True) # using pull away loss # EBGAN-PT
# Initializing
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %s" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
global_step = saved_global_step
start_epoch = global_step // (ds.num_images // model.batch_size
) # recover n_epoch
ds_iter.pointer = saved_global_step % (
ds.num_images // model.batch_size) # recover n_iter
for epoch in range(start_epoch, train_step['epochs']):
for batch_x in ds_iter.iterate():
batch_x = iu.transform(batch_x, inv_type='127')
batch_x = np.reshape(batch_x, (model.batch_size, model.height,
model.width, model.channel))
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
})
# Logging
if global_step % train_step['logging_interval'] == 0:
summary = s.run(model.merged,
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print(
"[+] Epoch %02d Step %08d => " % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g, feed_dict={
model.z: sample_z,
})
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(
global_step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# MNIST Dataset load
mnist = DataSet().data
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# CoGAN Model
model = cogan.CoGAN(s)
# Initializing
s.run(tf.global_variables_initializer())
sample_x, _ = mnist.test.next_batch(model.sample_num)
sample_y = np.zeros(shape=[model.sample_num, model.n_classes])
for i in range(10):
sample_y[10 * i:10 * (i + 1), i] = 1
for step in range(train_step['global_step']):
batch_x, batch_y = mnist.train.next_batch(model.batch_size)
batch_x = np.reshape(batch_x, model.image_shape)
batch_z = np.random.uniform(
-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run(
[model.d_op, model.d_loss],
feed_dict={
model.x_1: batch_x,
model.x_2: batch_x,
# model.y: batch_y,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run(
[model.g_op, model.g_loss],
feed_dict={
model.x_1: batch_x,
model.x_2: batch_x,
# model.y: batch_y,
model.z: batch_z,
})
if step % train_step['logging_interval'] == 0:
batch_x, batch_y = mnist.train.next_batch(model.batch_size)
batch_x = np.reshape(batch_x, model.image_shape)
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x_1: batch_x,
model.x_2: batch_x,
# model.y: batch_y,
model.z: batch_z,
})
# Print loss
print("[+] Step %08d => " % step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
# Training G model with sample image and noise
samples_1 = s.run(
model.g_sample_1,
feed_dict={
# model.y: sample_y,
model.z: sample_z,
})
samples_2 = s.run(
model.g_sample_2,
feed_dict={
# model.y: sample_y,
model.z: sample_z,
})
samples_1 = np.reshape(samples_1, [-1] + model.image_shape[1:])
samples_2 = np.reshape(samples_2, [-1] + model.image_shape[1:])
# Summary saver
model.writer.add_summary(summary, global_step=step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir_1 = results['output'] + 'train_1_{:08d}.png'.format(
step)
sample_dir_2 = results['output'] + 'train_2_{:08d}.png'.format(
step)
# Generated image save
iu.save_images(samples_1,
size=[sample_image_height, sample_image_width],
image_path=sample_dir_1)
iu.save_images(samples_2,
size=[sample_image_height, sample_image_width],
image_path=sample_dir_2)
# Model save
model.saver.save(s, results['model'], global_step=step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# MNIST Dataset Load
mnist = DataSet(ds_path="D:\\DataSet/mnist/").data
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# CGAN Model
model = cgan.CGAN(s, batch_size=train_step['batch_size'])
# initializing
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
sample_y = np.zeros(shape=[model.sample_num, model.n_classes])
for i in range(10):
sample_y[10 * i:10 * (i + 1), i] = 1
for global_step in range(saved_global_step, train_step['global_step']):
batch_x, batch_y = mnist.train.next_batch(model.batch_size)
batch_z = np.random.uniform(
-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run(
[model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.c: batch_y,
model.z: batch_z,
model.do_rate: 0.5,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.c: batch_y,
model.z: batch_z,
model.do_rate: 0.5,
})
# Logging
if global_step % train_step['logging_interval'] == 0:
batch_x, batch_y = mnist.test.next_batch(model.batch_size)
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.c: batch_y,
model.z: batch_z,
model.do_rate: 0.5,
})
# Print Loss
print("[+] Step %08d => " % global_step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g,
feed_dict={
model.c: sample_y,
model.z: sample_z,
model.do_rate: 0.0,
})
samples = np.reshape(samples, [-1, 28, 28, 1])
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(
global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
image_size = crop_size = 128
# CycleGAN Model
model = cyclegan.CycleGAN(s,
input_height=image_size,
input_width=image_size,
input_channel=3,
batch_size=train_step['batch_size'])
# Celeb-A DataSet images
data_set_name = 'vangogh2photo'
ds = DataSet(input_height=image_size,
input_width=image_size,
input_channel=3,
crop_size=crop_size,
batch_size=train_step['batch_size'],
name=data_set_name)
img_a = ds.images_a
img_b = ds.images_b
print("[*] image A shape : ", img_a.shape)
print("[*] image B shape : ", img_b.shape)
n_sample = model.sample_num
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir_a = results['output'] + 'valid_a.png'
sample_dir_b = results['output'] + 'valid_b.png'
sample_a, sample_b = img_a[:n_sample], img_b[:n_sample]
sample_a = np.reshape(sample_a, [-1] + model.image_shape[1:])
sample_b = np.reshape(sample_b, [-1] + model.image_shape[1:])
# Generated image save
iu.save_images(sample_a, [sample_image_height, sample_image_width],
sample_dir_a)
iu.save_images(sample_b, [sample_image_height, sample_image_width],
sample_dir_b)
print("[+] pre-processing elapsed time : {:.8f}s".format(time.time() -
start_time))
# Initializing
s.run(tf.global_variables_initializer())
global_step = 0
for epoch in range(train_step['epochs']):
# learning rate decay
lr_decay = 1.
if epoch >= 100 and epoch % 10 == 0:
lr_decay = (train_step['epochs'] -
epoch) / (train_step['epochs'] / 2.)
# re-implement DataIterator for multi-input
pointer = 0
num_images = min(ds.num_images_a, ds.num_images_b)
for i in range(num_images // train_step['batch_size']):
start = pointer
pointer += train_step['batch_size']
if pointer > num_images: # if ended 1 epoch
# Shuffle training DataSet
perm_a, perm_b = np.arange(ds.num_images_a), np.arange(
ds.num_images_b)
np.random.shuffle(perm_a)
np.random.shuffle(perm_b)
img_a, img_b = img_a[perm_a], img_a[perm_b]
start = 0
pointer = train_step['batch_size']
end = pointer
batch_a = np.reshape(img_a[start:end], model.image_shape)
batch_b = np.reshape(img_a[start:end], model.image_shape)
for _ in range(model.n_train_critic):
s.run(model.d_op,
feed_dict={
model.a: batch_a,
model.b: batch_b,
model.lr_decay: lr_decay,
})
w, gp, g_loss, cycle_loss, _ = s.run([
model.w, model.gp, model.g_loss, model.cycle_loss,
model.g_op
],
feed_dict={
model.a: batch_a,
model.b: batch_b,
model.lr_decay:
lr_decay,
})
if global_step % train_step['logging_step'] == 0:
# Summary
summary = s.run(model.merged,
feed_dict={
model.a: batch_a,
model.b: batch_b,
model.lr_decay: lr_decay,
})
# Print loss
print("[+] Global Step %08d =>" % global_step,
" G loss : {:.8f}".format(g_loss),
" Cycle loss : {:.8f}".format(cycle_loss),
" w : {:.8f}".format(w), " gp : {:.8f}".format(gp))
# Summary saver
model.writer.add_summary(summary, global_step=global_step)
# Training G model with sample image and noise
samples_a2b = s.run(model.g_a2b,
feed_dict={
model.a: sample_a,
model.b: sample_b,
model.lr_decay: lr_decay,
})
samples_b2a = s.run(model.g_b2a,
feed_dict={
model.a: sample_a,
model.b: sample_b,
model.lr_decay: lr_decay,
})
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir_a2b = results[
'output'] + 'train_a2b_{0}.png'.format(global_step)
sample_dir_b2a = results[
'output'] + 'train_b2a_{0}.png'.format(global_step)
# Generated image save
iu.save_images(samples_a2b,
[sample_image_height, sample_image_width],
sample_dir_a2b)
iu.save_images(samples_b2a,
[sample_image_height, sample_image_width],
sample_dir_b2a)
# Model save
model.saver.save(s,
results['model'],
global_step=global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# GPU configure
gpu_config = tf.GPUOptions(allow_growth=True)
config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_config)
with tf.Session(config=config) as s:
# BEGAN Model
model = began.BEGAN(s) # BEGAN
# Initializing
s.run(tf.global_variables_initializer())
# Celeb-A DataSet images
ds = DataSet(height=64,
width=64,
channel=3,
ds_path="/home/zero/hdd/DataSet/CelebA/",
ds_type="CelebA").images
ds_iter = DataIterator(ds, None, train_step['batch_size'],
label_off=True)
global_step = 0
for epoch in range(train_step['epoch']):
for batch_images in ds_iter.iterate():
batch_x = np.reshape(batch_images, [-1] + model.image_shape[1:])
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
})
# Update k_t
_, k, m_global = s.run([model.k_update, model.k, model.m_global],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
if global_step % train_step['logging_step'] == 0:
_, k, m_global, d_loss, g_loss, summary = s.run([model.k_update, model.k, model.m_global,
model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print("[+] Epoch %03d Step %07d =>" % (epoch, global_step),
" D loss : {:.6f}".format(d_loss),
" G loss : {:.6f}".format(g_loss),
" k : {:.6f}".format(k),
" M : {:.6f}".format(m_global))
# Summary saver
model.writer.add_summary(summary, global_step)
# Training G model with sample image and noise
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g,
feed_dict={
model.z: sample_z,
})
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}.png'.format(global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step=global_step)
# Learning Rate update
if global_step and global_step % model.lr_update_step == 0:
s.run([model.g_lr_update, model.d_lr_update])
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# DRAGAN model
model = dragan.DRAGAN(s, batch_size=train_step['batch_size'])
# Initializing variables
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %s" % saved_global_step, " successfully loaded")
else:
print('[-] No checkpoint file found')
# MNIST DataSet images
mnist = DataSet(ds_path="D:\\DataSet/mnist/").data
for global_step in range(saved_global_step, train_step['global_step']):
batch_x, _ = mnist.train.next_batch(model.batch_size)
batch_x_p = get_perturbed_images(batch_x)
batch_x = np.reshape(batch_x, [-1] + model.image_shape)
batch_x_p = np.reshape(batch_x_p, [-1] + model.image_shape)
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.x_p: batch_x_p,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
})
if global_step % train_step['logging_interval'] == 0:
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
d_loss, g_loss, summary = s.run([model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.x_p: batch_x_p,
model.z: batch_z,
})
# Print loss
print("[+] Global Step %05d => " % global_step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g,
feed_dict={
model.z: sample_z,
})
samples = np.reshape(samples, [-1] + model.image_shape)
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}.png'.format(global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # clocking start
# Dataset
dataset = DataSets(height=64,
width=64,
channel=3,
ds_path='D:/DataSets/pix2pix/',
ds_name="vangogh2photo")
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# DiscoGAN model
model = discogan.DiscoGAN(s)
# load model & graph & weight
global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
print("[+] global step : %s" % global_step, " successfully loaded")
else:
print('[-] No checkpoint file found')
# initializing variables
tf.global_variables_initializer().run()
d_overpowered = False # G loss > D loss * 2
for epoch in range(paras['epoch']):
for step in range(1000):
offsetA = (step * paras['batch_size']) % (dataset.img_A.shape[0] - paras['batch_size'])
offsetB = (step * paras['batch_size']) % (dataset.img_B.shape[0] - paras['batch_size'])
# batch data set
batch_A = dataset.img_A[offsetA:(offsetA + paras['batch_size']), :]
batch_B = dataset.img_B[offsetB:(offsetB + paras['batch_size']), :]
# update D network
if not d_overpowered:
s.run(model.d_op, feed_dict={model.A: batch_A})
# update G network
s.run(model.g_op, feed_dict={model.B: batch_B})
if epoch % paras['logging_interval'] == 0:
d_loss, g_loss, summary = s.run([
model.d_loss,
model.g_loss,
model.merged
], feed_dict={
model.A: batch_A,
model.B: batch_B
})
# print loss
print("[+] Epoch %03d Step %04d => " % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# update overpowered
d_overpowered = d_loss < g_loss / 2
# training G model with sample image and noise
AB_samples = s.run(model.G_s2b, feed_dict={model.A: batch_A})
BA_samples = s.run(model.G_b2s, feed_dict={model.B: batch_B})
# summary saver
model.writer.add_summary(summary, global_step=global_step)
# export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_AB_dir = results['sample_output'] + 'train_A_{0}_{1}.png'.format(epoch, global_step)
sample_BA_dir = results['sample_output'] + 'train_B_{0}_{1}.png'.format(epoch, global_step)
# Generated image save
iu.save_images(AB_samples, size=[sample_image_height, sample_image_width],
image_path=sample_AB_dir)
iu.save_images(BA_samples, size=[sample_image_height, sample_image_width],
image_path=sample_BA_dir)
# model save
model.saver.save(s, results['model'], global_step=global_step)
end_time = time.time() - start_time
# elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# LAPGAN model # D/G Models are same as DCGAN
model = lapgan.LAPGAN(s, batch_size=train_step['batch_size'])
# Initializing variables
s.run(tf.global_variables_initializer())
# Training, test data set
dataset = DataSet(input_height=32,
input_width=32,
input_channel=3,
name='cifar-10')
dataset_iter = DataIterator(dataset.train_images, dataset.train_labels,
train_step['batch_size'])
step = 0
cont = int(step / 750)
for epoch in range(cont, cont + train_step['epoch']):
for batch_images, batch_labels in dataset_iter.iterate():
batch_images = batch_images.astype(np.float32) / 225.
z = []
for i in range(3):
z.append(
np.random.uniform(
-1., 1.,
[train_step['batch_size'], model.z_noises[i]
]).astype(np.float32))
# Update D/G networks
img_fake, _, _, img_coarse, d_loss_1, g_loss_1, \
_, _, _, _, _, d_loss_2, g_loss_2, \
_, _, _, _, d_loss_3, g_loss_3, \
_, _, _, _, _, _ = s.run([
model.g[0], model.d_reals_prob[0], model.d_fakes_prob[0], model.x1_coarse,
model.d_loss[0], model.g_loss[0],
model.x2_fine, model.g[1], model.d_reals_prob[1], model.d_fakes_prob[1], model.x2_coarse,
model.d_loss[1], model.g_loss[1],
model.x3_fine, model.g[2], model.d_reals_prob[2], model.d_fakes_prob[2],
model.d_loss[2], model.g_loss[2],
model.d_op[0], model.g_op[0], model.d_op[1], model.g_op[1], model.d_op[2], model.g_op[2], # D/G ops
],
feed_dict={
model.x1_fine: batch_images, # images
model.y: batch_labels, # classes
model.z[0]: z[0], model.z[1]: z[1], model.z[2]: z[2] # z-noises
})
# Logging
if step % train_step['logging_interval'] == 0:
batch_x = batch_images[:model.sample_num]
batch_y = batch_labels[:model.sample_num]
z = []
for i in range(3):
z.append(
np.random.uniform(
-1., 1.,
[model.sample_num, model.z_noises[i]]).astype(
np.float32))
# Update D/G networks
img_fake, _, _, img_coarse, d_loss_1, g_loss_1, \
_, _, _, _, _, d_loss_2, g_loss_2, \
_, _, _, _, d_loss_3, g_loss_3, \
_, _, _, _, _, _, summary = s.run([
model.g[0], model.d_reals_prob[0], model.d_fakes_prob[0], model.x1_coarse,
model.d_loss[0], model.g_loss[0],
model.x2_fine, model.g[1], model.d_reals_prob[1], model.d_fakes_prob[1], model.x2_coarse,
model.d_loss[1], model.g_loss[1],
model.x3_fine, model.g[2], model.d_reals_prob[2], model.d_fakes_prob[2],
model.d_loss[2], model.g_loss[2],
model.d_op[0], model.g_op[0], model.d_op[1], model.g_op[1], model.d_op[2], model.g_op[2],
model.merged,
],
feed_dict={
model.x1_fine: batch_x, # images
model.y: batch_y, # classes
model.z[0]: z[0], model.z[1]: z[1], model.z[2]: z[2] # z-noises
})
# Print loss
print("[+] Epoch %03d Step %05d => " % (epoch, step),
" D loss : {:.8f}".format(d_loss_1.mean()),
" G loss : {:.8f}".format(g_loss_1.mean()))
# Training G model with sample image and noise
samples = img_fake + img_coarse
# Summary saver
model.writer.add_summary(summary, step) # time saving
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results[
'output'] + 'train_{0}_{1}.png'.format(epoch, step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'],
global_step=step) # time saving
step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# Div2K - Track 1: Bicubic downscaling - x4 DataSet load
"""
ds = DataSet(ds_path="/home/zero/hdd/DataSet/DIV2K/",
ds_name="X4",
use_save=True,
save_type="to_h5",
save_file_name="/home/zero/hdd/DataSet/DIV2K/DIV2K",
use_img_scale=True)
"""
ds = DataSet(ds_hr_path="/home/zero/hdd/DataSet/DIV2K/DIV2K-hr.h5",
ds_lr_path="/home/zero/hdd/DataSet/DIV2K/DIV2K-lr.h5",
use_img_scale=True)
hr, lr = ds.hr_images, ds.lr_images
print("[+] Loaded HR image ", hr.shape)
print("[+] Loaded LR image ", lr.shape)
# GPU configure
gpu_config = tf.GPUOptions(allow_growth=True)
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False,
gpu_options=gpu_config)
with tf.Session(config=config) as s:
with tf.device("/gpu:1"): # Change
# SRGAN Model
model = srgan.SRGAN(s,
batch_size=train_step['batch_size'],
use_vgg19=False)
# Initializing
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % global_step, " successfully loaded")
else:
global_step = 0
print('[-] No checkpoint file found')
start_epoch = global_step // (ds.n_images // train_step['batch_size'])
rnd = np.random.randint(0, ds.n_images)
sample_x_hr, sample_x_lr = hr[rnd], lr[rnd]
sample_x_hr, sample_x_lr = \
np.reshape(sample_x_hr, [1] + model.hr_image_shape[1:]), \
np.reshape(sample_x_lr, [1] + model.lr_image_shape[1:])
# Export real image
# valid_image_height = model.sample_size
# valid_image_width = model.sample_size
sample_hr_dir, sample_lr_dir = results[
'output'] + 'valid_hr.png', results['output'] + 'valid_lr.png'
# Generated image save
iu.save_images(sample_x_hr,
size=[1, 1],
image_path=sample_hr_dir,
inv_type='127')
iu.save_images(sample_x_lr,
size=[1, 1],
image_path=sample_lr_dir,
inv_type='127')
learning_rate = 1e-4
for epoch in range(start_epoch, train_step['train_epochs']):
pointer = 0
for i in range(ds.n_images // train_step['batch_size']):
start = pointer
pointer += train_step['batch_size']
if pointer > ds.n_images: # if 1 epoch is ended
# Shuffle training DataSet
perm = np.arange(ds.n_images)
np.random.shuffle(perm)
hr, lr = hr[perm], lr[perm]
start = 0
pointer = train_step['batch_size']
end = pointer
batch_x_hr, batch_x_lr = hr[start:end], lr[start:end]
# reshape
batch_x_hr = np.reshape(batch_x_hr,
[train_step['batch_size']] +
model.hr_image_shape[1:])
batch_x_lr = np.reshape(batch_x_lr,
[train_step['batch_size']] +
model.lr_image_shape[1:])
# Update Only G network
d_loss, g_loss, g_init_loss = 0., 0., 0.
if epoch <= train_step['init_epochs']:
_, g_init_loss = s.run(
[model.g_init_op, model.g_cnt_loss],
feed_dict={
model.x_hr: batch_x_hr,
model.x_lr: batch_x_lr,
model.lr: learning_rate,
})
# Update G/D network
else:
_, d_loss = s.run(
[model.d_op, model.d_loss],
feed_dict={
model.x_hr: batch_x_hr,
model.x_lr: batch_x_lr,
model.lr: learning_rate,
})
_, g_loss = s.run(
[model.g_op, model.g_loss],
feed_dict={
model.x_hr: batch_x_hr,
model.x_lr: batch_x_lr,
model.lr: learning_rate,
})
if i % train_step['logging_interval'] == 0:
# Print loss
if epoch <= train_step['init_epochs']:
print(
"[+] Epoch %04d Step %08d => " %
(epoch, global_step),
" MSE loss : {:.8f}".format(g_init_loss))
else:
print(
"[+] Epoch %04d Step %08d => " %
(epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
summary = s.run(model.merged,
feed_dict={
model.x_hr: batch_x_hr,
model.x_lr: batch_x_lr,
model.lr: learning_rate,
})
# Summary saver
model.writer.add_summary(summary, global_step)
# Training G model with sample image and noise
sample_x_lr = np.reshape(sample_x_lr, [model.sample_num] +
model.lr_image_shape[1:])
samples = s.run(model.g,
feed_dict={
model.x_lr: sample_x_lr,
model.lr: learning_rate,
})
# Export image generated by model G
# sample_image_height = model.output_height
# sample_image_width = model.output_width
sample_dir = results['output'] + 'train_{:08d}.png'.format(
global_step)
# Generated image save
iu.save_images(samples,
size=[1, 1],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step)
# Learning Rate update
if epoch and epoch % model.lr_update_epoch == 0:
learning_rate *= model.lr_decay_rate
learning_rate = max(learning_rate, model.lr_low_boundary)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# MNIST Dataset load
mnist = DataSet().data
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# InfoGAN Model
model = infogan.InfoGAN(s)
# Initializing
s.run(tf.global_variables_initializer())
sample_x, sample_y = mnist.test.next_batch(model.sample_num)
sample_x = np.reshape(sample_x, [-1] + model.image_shape[1:])
sample_z = np.random.uniform(
-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
sample_c = np.concatenate(
(sample_y, np.zeros([model.sample_num, model.n_cont])), axis=1)
d_overpowered = False
for step in range(train_step['global_step']):
batch_x, batch_y = mnist.train.next_batch(model.batch_size)
batch_x = np.reshape(batch_x, [-1] + model.image_shape[1:])
batch_z = np.random.uniform(
-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
batch_c = np.concatenate(
(batch_y, np.random.uniform(-1., 1., [model.batch_size, 2])),
axis=1)
# Update D network
if not d_overpowered:
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c,
})
d_overpowered = d_loss < g_loss / 2
# Logging
if step % train_step['logging_interval'] == 0:
batch_x, batch_y = mnist.test.next_batch(model.batch_size)
batch_x = np.reshape(batch_x, [-1] + model.image_shape[1:])
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
batch_c = np.concatenate(
(batch_y, np.random.uniform(-1., 1.,
[model.batch_size, 2])),
axis=1)
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
model.c: batch_c,
})
d_overpowered = d_loss < g_loss / 2
# Print loss
print("[+] Step %08d => " % step,
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: sample_z,
model.c: sample_c,
})
# Summary saver
model.writer.add_summary(summary, step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(
step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s, results['model'], global_step=step)
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# Training, Test data set
# loading Cifar DataSet
ds = DataSet(height=32,
width=32,
channel=3,
ds_path='D:\\DataSet/cifar/cifar-10-batches-py/',
ds_name='cifar-10')
# saving sample images
test_images = np.reshape(iu.transform(ds.test_images[:16], inv_type='127'), (16, 32, 32, 3))
iu.save_images(test_images,
size=[4, 4],
image_path=results['output'] + 'sample.png',
inv_type='127')
ds_iter = DataIterator(x=ds.train_images,
y=None,
batch_size=train_step['batch_size'],
label_off=True)
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# GAN Model
model = lsgan.LSGAN(s, train_step['batch_size'])
# Initializing variables
s.run(tf.global_variables_initializer())
# Load model & Graph & Weights
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step, " successfully loaded")
else:
print('[-] No checkpoint file found')
global_step = saved_global_step
start_epoch = global_step // (len(ds.train_images) // model.batch_size)
ds_iter.pointer = saved_global_step % (len(ds.train_images) // model.batch_size) # recover n_iter
for epoch in range(start_epoch, train_step['epoch']):
for batch_x in ds_iter.iterate():
batch_x = iu.transform(batch_x, inv_type='127')
batch_x = np.reshape(batch_x, [-1] + model.image_shape[1:])
batch_z = np.random.uniform(-1., 1., [model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z
})
# Logging
if global_step % train_step['logging_interval'] == 0:
d_loss, g_loss, summary = s.run([model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z
})
# Print loss
print("[+] Epoch %02d Step %08d => " % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Training G model with sample image and noise
sample_z = np.random.uniform(-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g,
feed_dict={
model.z: sample_z,
})
# Summary saver
model.writer.add_summary(summary, global_step)
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{:08d}.png'.format(global_step)
# Generated image save
iu.save_images(samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s, results['model'], global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# loading CelebA DataSet
ds = DataSet(
height=64,
width=64,
channel=3,
ds_image_path="/home/zero/hdd/DataSet/CelebA/CelebA-64.h5",
ds_label_path="/home/zero/hdd/DataSet/CelebA/Anno/list_attr_celeba.txt",
# ds_image_path="/home/zero/hdd/DataSet/CelebA/Img/img_align_celeba/",
ds_type="CelebA",
use_save=False,
save_file_name="/home/zero/hdd/DataSet/CelebA/CelebA-64.h5",
save_type="to_h5",
use_img_scale=False,
# img_scale="-1,1"
)
# saving sample images
test_images = np.reshape(iu.transform(ds.images[:100], inv_type='127'),
(100, 64, 64, 3))
iu.save_images(test_images,
size=[10, 10],
image_path=results['output'] + 'sample.png',
inv_type='127')
ds_iter = DataIterator(x=ds.images,
y=None,
batch_size=train_step['batch_size'],
label_off=True)
# GPU configure
gpu_config = tf.GPUOptions(allow_growth=True)
config = tf.ConfigProto(allow_soft_placement=True, gpu_options=gpu_config)
with tf.Session(config=config) as s:
# BEGAN Model
model = began.BEGAN(s, batch_size=train_step['batch_size'],
gamma=0.5) # BEGAN
# Initializing
s.run(tf.global_variables_initializer())
print("[*] Reading checkpoints...")
saved_global_step = 0
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
saved_global_step = int(
ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1])
print("[+] global step : %d" % saved_global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
global_step = saved_global_step
start_epoch = global_step // (ds.num_images // model.batch_size
) # recover n_epoch
ds_iter.pointer = saved_global_step % (
ds.num_images // model.batch_size) # recover n_iter
for epoch in range(start_epoch, train_step['epoch']):
for batch_x in ds_iter.iterate():
batch_x = iu.transform(batch_x, inv_type='127')
batch_x = np.reshape(batch_x, (model.batch_size, model.height,
model.width, model.channel))
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
})
# Update k_t
_, k, m_global = s.run(
[model.k_update, model.k, model.m_global],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
if global_step % train_step['logging_step'] == 0:
summary = s.run(model.merged,
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print("[+] Epoch %03d Step %07d =>" % (epoch, global_step),
" D loss : {:.6f}".format(d_loss),
" G loss : {:.6f}".format(g_loss),
" k : {:.6f}".format(k),
" M : {:.6f}".format(m_global))
# Summary saver
model.writer.add_summary(summary, global_step)
# Training G model with sample image and noise
sample_z = np.random.uniform(
-1., 1.,
[model.sample_num, model.z_dim]).astype(np.float32)
samples = s.run(model.g, feed_dict={
model.z: sample_z,
})
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}.png'.format(
global_step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir,
inv_type='127')
# Model save
model.saver.save(s,
results['model'],
global_step=global_step)
# Learning Rate update
if global_step and global_step % model.lr_update_step == 0:
s.run([model.g_lr_update, model.d_lr_update])
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
def main():
start_time = time.time() # Clocking start
# GPU configure
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as s:
# AnoGAN Model
# anomalies detect off (just training model) -> False
# anomalies detect on (based on trained model-> True
if not os.path.exists('./model'):
detection = False
else:
detection = True
model = anogan.AnoGAN(s, detect=detection) # AnoGAN
global_step = 0
if detection:
# Load model & Graph & Weights
ckpt = tf.train.get_checkpoint_state('./model/')
if ckpt and ckpt.model_checkpoint_path:
# Restores from checkpoint
model.saver.restore(s, ckpt.model_checkpoint_path)
global_step = ckpt.model_checkpoint_path.split('/')[-1].split(
'-')[-1]
print("[+] global step : %s" % global_step,
" successfully loaded")
else:
print('[-] No checkpoint file found')
# Initializing
s.run(tf.global_variables_initializer())
# Celeb-A DataSet images
ds = DataSet(
input_height=64, # in the paper, 108
input_width=64, # in the paper, 108
input_channel=3).images
# To-Do
# Getting anomaly data
dataset_iter = DataIterator(ds,
None,
train_step['batch_size'],
label_off=True)
sample_x = ds[:model.sample_num]
sample_x = np.reshape(sample_x, [-1] + model.image_shape[1:])
sample_z = np.random.uniform(
-1., 1., [model.sample_num, model.z_dim]).astype(np.float32)
# Export real image
valid_image_height = model.sample_size
valid_image_width = model.sample_size
sample_dir = results['output'] + 'valid.png'
# Generated image save
iu.save_images(sample_x,
size=[valid_image_height, valid_image_width],
image_path=sample_dir)
for epoch in range(train_step['epoch']):
for batch_images in dataset_iter.iterate():
batch_x = np.reshape(batch_images,
[-1] + model.image_shape[1:])
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
# Update D network
_, d_loss = s.run([model.d_op, model.d_loss],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Update G network
_, g_loss = s.run([model.g_op, model.g_loss],
feed_dict={
model.z: batch_z,
})
if global_step % train_step['logging_step'] == 0:
batch_z = np.random.uniform(
-1., 1.,
[model.batch_size, model.z_dim]).astype(np.float32)
# Summary
d_loss, g_loss, summary = s.run(
[model.d_loss, model.g_loss, model.merged],
feed_dict={
model.x: batch_x,
model.z: batch_z,
})
# Print loss
print("[+] Epoch %04d Step %07d =>" % (epoch, global_step),
" D loss : {:.8f}".format(d_loss),
" G loss : {:.8f}".format(g_loss))
# Summary saver
model.writer.add_summary(summary, epoch)
# Training G model with sample image and noise
samples = s.run(model.g,
feed_dict={
model.x: sample_x,
model.z: sample_z,
})
# Export image generated by model G
sample_image_height = model.sample_size
sample_image_width = model.sample_size
sample_dir = results['output'] + 'train_{0}_{1}.png'.format(
epoch, global_step)
# Generated image save
iu.save_images(
samples,
size=[sample_image_height, sample_image_width],
image_path=sample_dir)
# Model save
model.saver.save(s,
results['model'],
global_step=global_step)
global_step += 1
end_time = time.time() - start_time # Clocking end
# Elapsed time
print("[+] Elapsed time {:.8f}s".format(end_time))
# Close tf.Session
s.close()
