def train():
images, images_path = get_celebA(flags.output_size, flags.n_epoch,
flags.batch_size)
G = get_generator([None, flags.z_dim])
D = get_discriminator(
[None, flags.output_size, flags.output_size, flags.c_dim])
G.train()
D.train()
d_optimizer = tf.optimizers.Adam(flags.lr, beta_1=flags.beta1)
g_optimizer = tf.optimizers.Adam(flags.lr, beta_1=flags.beta1)
n_step_epoch = int(len(images_path) // flags.batch_size)
for epoch in range(flags.n_epoch):
for step, batch_images in enumerate(images):
if batch_images.shape[0] != flags.batch_size:
break
step_time = time.time()
with tf.GradientTape(persistent=True) as tape:
z = np.random.normal(loc=0.0,
scale=1.0,
size=[flags.batch_size,
flags.z_dim]).astype(np.float32)
d_logits = D(G(z))
d2_logits = D(batch_images)
# discriminator: real images are labelled as 1
d_loss_real = tl.cost.sigmoid_cross_entropy(
d2_logits, tf.ones_like(d2_logits), name='dreal')
# discriminator: images from generator (fake) are labelled as 0
d_loss_fake = tl.cost.sigmoid_cross_entropy(
d_logits, tf.zeros_like(d_logits), name='dfake')
# combined loss for updating discriminator
d_loss = d_loss_real + d_loss_fake
# generator: try to fool discriminator to output 1
g_loss = tl.cost.sigmoid_cross_entropy(d_logits,
tf.ones_like(d_logits),
name='gfake')
grad = tape.gradient(g_loss, G.trainable_weights)
g_optimizer.apply_gradients(zip(grad, G.trainable_weights))
grad = tape.gradient(d_loss, D.trainable_weights)
d_optimizer.apply_gradients(zip(grad, D.trainable_weights))
del tape
if step % flags.print_every_step == 0:
print("Epoch: [{}/{}] [{}/{}] took: {:3f}, d_loss: {:5f}, g_loss: {:5f}".format(epoch, \
flags.n_epoch, step, n_step_epoch, time.time()-step_time, d_loss, g_loss))
if np.mod(epoch, flags.save_every_epoch) == 0:
G.save_weights('{}/G_{}.h5'.format(flags.checkpoint_dir, epoch))
D.save_weights('{}/D_{}.h5'.format(flags.checkpoint_dir, epoch))
G.eval()
result = G(z)
G.train()
tl.visualize.save_images(
result.numpy(), [num_tiles, num_tiles],
'{}/train_{:02d}.png'.format(flags.sample_dir, epoch))
def recon():
ds, _ = get_celebA(flags.output_size, 1, 1)
for im in ds:
if input() == 'q':
break
#print(im)
rec = G(E(im))
plt.imshow(np.array((im + 1.) * 127.5, dtype=np.uint8)[0])
plt.show()
plt.imshow(np.array((rec + 1.) * 127.5, dtype=np.uint8)[0])
plt.show()
def test(weights_pathG, weights_pathE, real_path='real_image.png', reproduced_path='reproduced_image.png'):
images, images_path = get_celebA(flags.output_size, flags.n_epoch, flags.batch_size)
num_tiles = int(math.ceil(math.sqrt(flags.sample_size)))
G = get_generator([None, flags.z_dim])
G.load_weights(weights_pathG, format='npz')
G.eval()
E = get_encoder([None, flags.output_size, flags.output_size, flags.c_dim])
E.load_weights(weights_pathE, format='npz')
E.eval()
for step, batch_images in enumerate(images):
if batch_images.shape[0] != flags.batch_size:
break
result = G(E(batch_images))
tl.visualize.save_images(batch_images.numpy(), [num_tiles, num_tiles], real_path)
tl.visualize.save_images(result.numpy(), [num_tiles, num_tiles], reproduced_path)
break
def train():
images, images_path = get_celebA(flags.output_size, flags.n_epoch,
flags.batch_size)
G = get_generator()
E = get_encoder()
G.load_weights(G_weights)
G.train()
E.train()
optimizer = tf.optimizers.Adam(learning_rate, beta_1=flags.beta1)
n_step_epoch = int(len(images_path) // flags.batch_size)
for epoch in range(n_epoch):
for step, batch_images in enumerate(images):
if batch_images.shape[0] != flags.batch_size:
break
step_time = time.time()
with tf.GradientTape() as tape:
z = np.random.normal(loc=0.0,
scale=1.0,
size=[batch_size,
flags.z_dim]).astype(np.float32)
gen = G(z)
z_encode = E(gen)
x_encode = E(batch_images)
x_decode = G(x_encode)
z_recon_loss = tl.cost.absolute_difference_error(z_encode,
z,
is_mean=True)
x_recon_loss = 5. * tl.cost.absolute_difference_error(
x_decode, batch_images, is_mean=True)
loss = z_recon_loss + x_recon_loss
grad = tape.gradient(loss, E.trainable_weights)
optimizer.apply_gradients(zip(grad, E.trainable_weights))
if step % print_every_step == 0:
print('Epoch: [{}/{}] step: [{}/{}] took: {:3f}, z_recon_loss: {:5f}, x_recon_loss: {:5f}'.format(epoch, n_epoch,\
step, n_step_epoch, time.time()-step_time, z_recon_loss, x_recon_loss))
if epoch % save_every_epoch == 0:
E.save_weights('{}/E_{}.h5'.format(flags.checkpoint_dir, epoch))
def train():
images, images_path = get_celebA(flags.output_size, flags.n_epoch,
flags.batch_size)
G = get_generator([None, flags.z_dim])
D = get_discriminator(
[None, flags.output_size, flags.output_size, flags.c_dim])
G.train()
D.train()
d_optimizer = tf.optimizers.Adam(flags.learning_rate, beta_1=flags.beta1)
g_optimizer = tf.optimizers.Adam(flags.learning_rate, beta_1=flags.beta1)
n_step_epoch = int(len(images_path) // flags.batch_size)
for step, batch_images in enumerate(images):
step_time = time.time()
with tf.GradientTape(persistent=True) as tape:
# z = tf.distributions.Normal(0., 1.).sample([flags.batch_size, flags.z_dim]) #tf.placeholder(tf.float32, [None, z_dim], name='z_noise')
z = np.random.normal(loc=0.0,
scale=1.0,
size=[flags.batch_size,
flags.z_dim]).astype(np.float32)
d_logits = D(G(z))
d2_logits = D(batch_images)
# discriminator: real images are labelled as 1
d_loss_real = tl.cost.sigmoid_cross_entropy(
d2_logits, tf.ones_like(d2_logits), name='dreal')
# discriminator: images from generator (fake) are labelled as 0
d_loss_fake = tl.cost.sigmoid_cross_entropy(
d_logits, tf.zeros_like(d_logits), name='dfake')
# combined loss for updating discriminator
d_loss = d_loss_real + d_loss_fake
# generator: try to fool discriminator to output 1
g_loss = tl.cost.sigmoid_cross_entropy(d_logits,
tf.ones_like(d_logits),
name='gfake')
grad = tape.gradient(g_loss, G.weights)
g_optimizer.apply_gradients(zip(grad, G.weights))
grad = tape.gradient(d_loss, D.weights)
d_optimizer.apply_gradients(zip(grad, D.weights))
del tape
print(
"Epoch: [{}/{}] [{}/{}] took: {:3f}, d_loss: {:5f}, g_loss: {:5f}".
format(step // n_step_epoch, flags.n_epoch, step, n_step_epoch,
time.time() - step_time, d_loss, g_loss))
if np.mod(step, flags.save_step) == 0:
G.save_weights('{}/G.npz'.format(flags.checkpoint_dir),
format='npz')
D.save_weights('{}/D.npz'.format(flags.checkpoint_dir),
format='npz')
G.eval()
result = G(z)
G.train()
tl.visualize.save_images(
result.numpy(), [num_tiles, num_tiles],
'{}/train_{:02d}_{:04d}.png'.format(flags.sample_dir,
step // n_step_epoch,
step))
def train():
images, images_path = get_celebA(flags.output_size, flags.n_epoch,
flags.batch_size)
G = get_generator([None, flags.z_dim])
D = get_discriminator(
[None, flags.z_dim],
[None, flags.output_size, flags.output_size, flags.c_dim])
E = get_encoder([None, flags.output_size, flags.output_size, flags.c_dim])
if flags.load_weights:
E.load_weights('checkpoint/E.npz', format='npz')
G.load_weights('checkpoint/G.npz', format='npz')
D.load_weights('checkpoint/D.npz', format='npz')
G.train()
D.train()
E.train()
d_optimizer = tf.optimizers.Adam(flags.lr, beta_1=flags.beta1)
g_optimizer = tf.optimizers.Adam(flags.lr, beta_1=flags.beta1)
e_optimizer = tf.optimizers.Adam(flags.lr, beta_1=flags.beta1)
n_step_epoch = int(len(images_path) // flags.batch_size)
for epoch in range(flags.n_epoch):
for step, batch_images in enumerate(images):
if batch_images.shape[0] != flags.batch_size:
break
step_time = time.time()
with tf.GradientTape(persistent=True) as tape:
z = np.random.normal(loc=0.0,
scale=1.0,
size=[flags.batch_size,
flags.z_dim]).astype(np.float32)
d_logits = D([G(z), z])
d2_logits = D([batch_images, E(batch_images)])
d_loss_real = tl.cost.sigmoid_cross_entropy(
d2_logits, tf.ones_like(d2_logits), name='dreal')
d_loss_fake = tl.cost.sigmoid_cross_entropy(
d_logits, tf.zeros_like(d_logits), name='dfake')
d_loss = d_loss_fake + d_loss_real
g_loss = tl.cost.sigmoid_cross_entropy(d_logits,
tf.ones_like(d_logits),
name='gfake')
e_loss = tl.cost.sigmoid_cross_entropy(
d2_logits, tf.zeros_like(d2_logits), name='ereal')
grad = tape.gradient(g_loss, G.trainable_weights)
g_optimizer.apply_gradients(zip(grad, G.trainable_weights))
grad = tape.gradient(d_loss, D.trainable_weights)
d_optimizer.apply_gradients(zip(grad, D.trainable_weights))
grad = tape.gradient(e_loss, E.trainable_weights)
e_optimizer.apply_gradients(zip(grad, E.trainable_weights))
del tape
print(
"Epoch: [{}/{}] [{}/{}] took: {:.3f}, d_loss: {:.5f}, g_loss: {:.5f}, e_loss: {:.5f}"
.format(epoch, flags.n_epoch, step, n_step_epoch,
time.time() - step_time, d_loss, g_loss, e_loss))
if np.mod(epoch, flags.save_every_epoch) == 0:
G.save_weights('{}/G.npz'.format(flags.checkpoint_dir),
format='npz')
D.save_weights('{}/D.npz'.format(flags.checkpoint_dir),
format='npz')
E.save_weights('{}/E.npz'.format(flags.checkpoint_dir),
format='npz')
G.eval()
result = G(z)
G.train()
tl.visualize.save_images(
result.numpy(), [num_tiles, num_tiles],
'{}/train_{:02d}.png'.format(flags.sample_dir, epoch))
for step, batch_images in enumerate(images):
if batch_images.shape[0] != flags.batch_size:
break
result = G(E(batch_images))
tl.visualize.save_images(
batch_images.numpy(), [num_tiles, num_tiles],
'{}/real_{:02d}.png'.format(flags.pair_dir, epoch))
tl.visualize.save_images(
result.numpy(), [num_tiles, num_tiles],
'{}/reproduced_{:02d}.png'.format(flags.pair_dir, epoch))
break
def train():
images, images_path = get_celebA(flags.output_size, flags.n_epoch,
flags.batch_size)
G = get_G([None, flags.dim_z])
Base = get_base(
[None, flags.output_size, flags.output_size, flags.n_channel])
D = get_D([None, 4096])
Q = get_Q([None, 4096])
G.train()
Base.train()
D.train()
Q.train()
g_optimizer = tf.optimizers.Adam(learning_rate=flags.G_learning_rate,
beta_1=flags.beta_1)
d_optimizer = tf.optimizers.Adam(learning_rate=flags.D_learning_rate,
beta_1=flags.beta_1)
n_step_epoch = int(len(images_path) // flags.batch_size)
his_g_loss = []
his_d_loss = []
his_mutual = []
count = 0
for epoch in range(flags.n_epoch):
for step, batch_images in enumerate(images):
count += 1
if batch_images.shape[0] != flags.batch_size:
break
step_time = time.time()
with tf.GradientTape(persistent=True) as tape:
z, c = gen_noise()
fake = Base(G(z))
fake_logits = D(fake)
fake_cat = Q(fake)
real_logits = D(Base(batch_images))
d_loss_fake = tl.cost.sigmoid_cross_entropy(
output=fake_logits,
target=tf.zeros_like(fake_logits),
name='d_loss_fake')
d_loss_real = tl.cost.sigmoid_cross_entropy(
output=real_logits,
target=tf.ones_like(real_logits),
name='d_loss_real')
d_loss = d_loss_fake + d_loss_real
g_loss = tl.cost.sigmoid_cross_entropy(
output=fake_logits,
target=tf.ones_like(fake_logits),
name='g_loss_fake')
mutual = calc_mutual(fake_cat, c)
g_loss += mutual
grad = tape.gradient(g_loss,
G.trainable_weights + Q.trainable_weights)
g_optimizer.apply_gradients(
zip(grad, G.trainable_weights + Q.trainable_weights))
grad = tape.gradient(d_loss,
D.trainable_weights + Base.trainable_weights)
d_optimizer.apply_gradients(
zip(grad, D.trainable_weights + Base.trainable_weights))
del tape
print(
f"Epoch: [{epoch}/{flags.n_epoch}] [{step}/{n_step_epoch}] took: {time.time()-step_time:.3f}, d_loss: {d_loss:.5f}, g_loss: {g_loss:.5f}, mutual: {mutual:.5f}"
)
if count % flags.save_every_it == 1:
his_g_loss.append(g_loss)
his_d_loss.append(d_loss)
his_mutual.append(mutual)
plt.plot(his_d_loss)
plt.plot(his_g_loss)
plt.plot(his_mutual)
plt.legend(['D_Loss', 'G_Loss', 'Mutual_Info'])
plt.xlabel(f'Iterations / {flags.save_every_it}')
plt.ylabel('Loss')
plt.savefig(f'{flags.result_dir}/loss.jpg')
plt.clf()
plt.close()
G.save_weights(f'{flags.checkpoint_dir}/G.npz', format='npz')
D.save_weights(f'{flags.checkpoint_dir}/D.npz', format='npz')
G.eval()
for k in range(flags.n_categorical):
z = gen_eval_noise(k, flags.n_sample)
result = G(z)
tl.visualize.save_images(convert(result.numpy()),
[flags.n_sample, flags.dim_categorical],
f'result/train_{epoch}_{k}.png')
G.train()
