def test(self):
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
print('Load checkpoint')
if ckpt and ckpt.model_checkpoint_path:
self.saver.restore(sess, ckpt.model_checkpoint_path)
print('Load Succeed!')
else:
print('Do not exists any checkpoint,Load Failed!')
exit()
_, _, _, testbatch, testmask = self.dataset.input()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
batch_num = 1000 / self.opt.batch_size
for j in range(batch_num):
real_test_batch, real_eye_pos = sess.run([testbatch, testmask])
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_eye_pos)
f_d = {
self.x: real_test_batch,
self.xm: batch_masks,
self.x_left_p: batch_left_eye_pos,
self.x_right_p: batch_right_eye_pos
}
for i in range(self.opt.batch_size):
output = sess.run([self.x, self.y], feed_dict=f_d)
output_concat = self.Transpose(
np.array([output[0], output[1]]))
save_images(
np.reshape(
output_concat, '{}/{:02d}_{:2d}.jpg'.format(
self.opt.test_sample_dir, j, i)))
coord.request_stop()
coord.join(threads)
def test(self):
self.saver = tf.train.Saver()
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
if ckpt and ckpt.model_checkpoint_path:
self.saver.restore(sess, ckpt.model_checkpoint_path)
else:
print("Do not found the pretrained model")
print("Start read dataset")
_, _, te_img, te_label = self.dataset.input()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
print("Start entering the looping")
for i in range(2000):
print(i)
_te_img, _te_label = sess.run([te_img, te_label])
f_d = {self.x: _te_img, self.label: _te_label}
te_o = sess.run([self.x, self._x], feed_dict=f_d)
te_x_list = np.split(te_o[1],
indices_or_sections=self.opt.n_att * 2,
axis=-1)
te_x_list.insert(0, te_o[0])
_te_o = self.Transpose(te_x_list)
save_images(
_te_o, '{}/{:02d}_te.jpg'.format(self.opt.test_sample_dir,
i))
coord.request_stop()
coord.join(threads)
def train(self):
self.t_vars = tf.trainable_variables()
self.d_vars = [var for var in self.t_vars if 'D' in var.name]
self.g_vars = [var for var in self.t_vars if 'G' in var.name]
self.e_vars = [var for var in self.t_vars if 'encode' in var.name]
assert len(self.t_vars) == len(self.d_vars + self.g_vars + self.e_vars)
self.saver = tf.train.Saver()
self.p_saver = tf.train.Saver(self.e_vars)
opti_D = tf.train.AdamOptimizer(self.opt.lr_d * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2).\
minimize(loss=self.D_loss, var_list=self.d_vars)
opti_G = tf.train.AdamOptimizer(self.opt.lr_g * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2).\
minimize(loss=self.G_loss, var_list=self.g_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
start_step = 0
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
self.saver.restore(sess, ckpt.model_checkpoint_path)
else:
print("")
# try:
# #self.p_saver.restore(sess, os.path.join(self.opt.pretrain_path,
# # 'model_{:06d}.ckpt'.format(100000)))
# except:
# print(" Self-Guided Model path may not be correct")
#summary_op = tf.summary.merge_all()
#summary_writer = tf.summary.FileWriter(self.opt.log_dir, sess.graph)
step = start_step
lr_decay = 1
print("Start read dataset")
image_path, train_images, train_eye_pos, test_images, test_eye_pos = self.dataset.input(
)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
print("Start entering the looping")
real_test_batch, real_test_pos = sess.run(
[test_images, test_eye_pos])
while step <= self.opt.niter:
if step > 20000 and step % 2000 == 0:
lr_decay = (self.opt.niter - step) / float(self.opt.niter -
20000)
real_batch_image_path, x_data, x_p_data = sess.run(
[image_path, train_images, train_eye_pos])
xm_data, x_left_p_data, x_right_p_data = self.get_Mask_and_pos(
x_p_data)
f_d = {
self.x: x_data,
self.xm: xm_data,
self.x_left_p: x_left_p_data,
self.x_right_p: x_right_p_data,
self.lr_decay: lr_decay
}
# optimize D
sess.run(opti_D, feed_dict=f_d)
# optimize G
sess.run(opti_G, feed_dict=f_d)
#summary_str = sess.run(summary_op, feed_dict=f_d)
#summary_writer.add_summary(summary_str, step)
if step % 500 == 0:
if self.opt.is_ss:
output_loss = sess.run([
self.D_loss, self.G_loss, self.opt.lam_r *
self.recon_loss, self.opt.lam_p * self.percep_loss,
self.r_cls_loss, self.f_cls_loss
],
feed_dict=f_d)
print(
"step %d D_loss=%.8f, G_loss=%.4f, Recon_loss=%.4f, Percep_loss=%.4f, "
"Real_class_loss=%.4f, Fake_class_loss=%.4f, lr_decay=%.4f"
% (step, output_loss[0], output_loss[1],
output_loss[2], output_loss[3], output_loss[4],
output_loss[5], lr_decay))
else:
output_loss = sess.run([
self.D_loss, self.G_loss, self.opt.lam_r *
self.recon_loss, self.opt.lam_p * self.percep_loss
],
feed_dict=f_d)
print(
"step %d D_loss=%.8f, G_loss=%.4f, Recon_loss=%.4f, Percep_loss=%.4f, lr_decay=%.4f"
% (step, output_loss[0], output_loss[1],
output_loss[2], output_loss[3], lr_decay))
if np.mod(step, 2000) == 0:
train_output_img = sess.run([
self.xl_left, self.xl_right, self.xc, self.yo, self.y,
self.yl_left, self.yl_right
],
feed_dict=f_d)
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_test_pos)
#for test
f_d = {
self.x: real_test_batch,
self.xm: batch_masks,
self.x_left_p: batch_left_eye_pos,
self.x_right_p: batch_right_eye_pos,
self.lr_decay: lr_decay
}
test_output_img = sess.run([self.xc, self.yo, self.y],
feed_dict=f_d)
output_concat = self.Transpose(
np.array([
x_data, train_output_img[2], train_output_img[3],
train_output_img[4]
]))
local_output_concat = self.Transpose(
np.array([
train_output_img[0], train_output_img[1],
train_output_img[5], train_output_img[6]
]))
test_output_concat = self.Transpose(
np.array([
real_test_batch, test_output_img[0],
test_output_img[2], test_output_img[1]
]))
save_images(
local_output_concat,
'{}/{:02d}_local_output.jpg'.format(
self.opt.sample_dir, step))
save_images(
output_concat,
'{}/{:02d}_output.jpg'.format(self.opt.sample_dir,
step))
save_images(
test_output_concat, '{}/{:02d}_test_output.jpg'.format(
self.opt.sample_dir, step))
if np.mod(step, 20000) == 0:
self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
#summary_writer.close()
coord.request_stop()
coord.join(threads)
print("Model saved in file: %s" % save_path)
def train(self):
self.t_vars = tf.trainable_variables()
self.d_vars = [var for var in self.t_vars if 'D' in var.name]
self.g_vars = [var for var in self.t_vars if 'G' in var.name]
assert len(self.t_vars) == len(self.d_vars + self.g_vars)
self.saver = tf.train.Saver()
opti_D = tf.train.AdamOptimizer(self.opt.lr_d * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2).\
minimize(loss=self.D_loss, var_list=self.d_vars)
opti_G = tf.train.AdamOptimizer(self.opt.lr_g * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2).\
minimize(loss=self.G_loss, var_list=self.g_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
self.saver.restore(sess, ckpt.model_checkpoint_path)
else:
start_step = 0
step = start_step
lr_decay = 1
print("Start read dataset")
tr_img, tr_label, te_img, te_label = self.dataset.input()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
_te_img, _te_label = sess.run([te_img, te_label])
print("Start entering the looping")
while step <= self.opt.niter:
if step > 20000 and step % 2000 == 0:
lr_decay = (self.opt.niter - step) / float(self.opt.niter -
20000)
_tr_img, _tr_label = sess.run([tr_img, tr_label])
f_d = {
self.x: _tr_img,
self.label: _tr_label,
self.lr_decay: lr_decay
}
# optimize D
sess.run(opti_D, feed_dict=f_d)
# optimize G
if step % self.opt.n_critic == 0:
sess.run(opti_G, feed_dict=f_d)
if step % 500 == 0:
o_loss = sess.run([self.D_loss, self.G_loss],
feed_dict=f_d)
print("step %d D_loss=%.8f, G_loss=%.4f lr_decay=%.4f" %
(step, o_loss[0], o_loss[1], lr_decay))
if np.mod(step, 2000) == 0:
tr_o = sess.run([self.x, self._x], feed_dict=f_d)
f_d = {self.x: _te_img, self.label: _te_label}
te_o = sess.run([self.x, self._x], feed_dict=f_d)
tr_x_list = np.split(tr_o[1],
indices_or_sections=self.opt.n_att *
2,
axis=-1)
te_x_list = np.split(te_o[1],
indices_or_sections=self.opt.n_att *
2,
axis=-1)
tr_x_list.insert(0, tr_o[0])
te_x_list.insert(0, te_o[0])
_tr_o = self.Transpose(tr_x_list)
_te_o = self.Transpose(te_x_list)
save_images(
_tr_o,
'{}/{:02d}_tr.jpg'.format(self.opt.sample_dir, step))
save_images(
_te_o,
'{}/{:02d}_te.jpg'.format(self.opt.sample_dir, step))
if np.mod(step, self.opt.save_model_freq) == 0:
self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
coord.request_stop()
coord.join(threads)
print("Model saved in file: %s" % save_path)
def train(self):
opti_D = tf.train.AdamOptimizer(self.d_learning_rate * self.lr_decay,beta1=self.beta1, beta2=self.beta2).\
minimize(loss=self.D_loss, var_list=self.d_vars)
opti_G = tf.train.AdamOptimizer(self.g_learning_rate * self.lr_decay,beta1=self.beta1, beta2=self.beta2).\
minimize(loss=self.G_loss, var_list=self.ed_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
start_step = 0
ckpt = tf.train.get_checkpoint_state(self.model_dir)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
self.saver.restore(sess, ckpt.model_checkpoint_path)
else:
try:
self.pretrain_saver.restore(
sess,
os.path.join(
self.pretrain_model_dir,
'model_{:06d}.ckpt'.format(
self.pretrain_model_index)))
except:
print(" Self-Guided Model path may not be correct")
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(self.log_dir, sess.graph)
step = start_step
lr_decay = self.lr_init
print("Start read dataset")
image_path, train_images, train_eye_pos, test_images, test_eye_pos = self.dataset.input(
)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
print("Start entering the looping")
real_test_batch, real_test_pos = sess.run(
[test_images, test_eye_pos])
while step <= self.max_iters:
if step > 20000 and step % 2000 == 0:
lr_decay = (self.max_iters - step) / float(self.max_iters -
20000)
real_batch_image_path, real_batch_image, real_eye_pos = sess.run(
[image_path, train_images, train_eye_pos])
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_eye_pos)
f_d = {
self.input: real_batch_image,
self.mask: batch_masks,
self.input_left_labels: batch_left_eye_pos,
self.input_right_labels: batch_right_eye_pos,
self.lr_decay: lr_decay
}
# optimize D
sess.run(opti_D, feed_dict=f_d)
# optimize G
sess.run(opti_G, feed_dict=f_d)
summary_str = sess.run(summary_op, feed_dict=f_d)
summary_writer.add_summary(summary_str, step)
if step % 500 == 0:
if self.is_supervised:
output_loss = sess.run([
self.D_loss, self.G_loss,
self.lam_recon * self.recon_loss,
self.lam_percep * self.percep_loss,
self.real_class_loss, self.fake_class_loss
],
feed_dict=f_d)
print(
"step %d D_loss=%.8f, G_loss=%.4f, Recon_loss=%.4f, Percep_loss=%.4f, "
"Real_class_loss=%.4f, Fake_class_loss=%.4f, lr_decay=%.4f"
% (step, output_loss[0], output_loss[1],
output_loss[2], output_loss[3], output_loss[4],
output_loss[5], lr_decay))
else:
output_loss = sess.run([
self.D_loss, self.G_loss, self.lam_recon *
self.recon_loss, self.lam_percep * self.percep_loss
],
feed_dict=f_d)
print(
"step %d D_loss=%.8f, G_loss=%.4f, Recon_loss=%.4f, Percep_loss=%.4f, lr_decay=%.4f"
% (step, output_loss[0], output_loss[1],
output_loss[2], output_loss[3], lr_decay))
if np.mod(step, 2000) == 0:
train_output_img = sess.run([
self.local_input_left, self.local_input_right,
self.incomplete_img, self.recon_img,
self.new_recon_img, self.local_recon_img_left,
self.local_recon_img_right
],
feed_dict=f_d)
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_test_pos)
#for test
f_d = {
self.input: real_test_batch,
self.mask: batch_masks,
self.input_left_labels: batch_left_eye_pos,
self.input_right_labels: batch_right_eye_pos,
self.lr_decay: lr_decay
}
test_output_img = sess.run([
self.incomplete_img, self.recon_img, self.new_recon_img
],
feed_dict=f_d)
output_concat = np.concatenate([
real_batch_image, train_output_img[2],
train_output_img[3], train_output_img[4]
],
axis=0)
local_output_concat = np.concatenate([
train_output_img[0], train_output_img[1],
train_output_img[5], train_output_img[6]
],
axis=0)
test_output_concat = np.concatenate([
real_test_batch, test_output_img[0],
test_output_img[2], test_output_img[1]
],
axis=0)
save_images(
local_output_concat, [
local_output_concat.shape[0] / self.batch_size,
self.batch_size
], '{}/{:02d}_local_output.jpg'.format(
self.sample_dir, step))
save_images(
output_concat, [
output_concat.shape[0] / self.batch_size,
self.batch_size
],
'{}/{:02d}_output.jpg'.format(self.sample_dir, step))
save_images(
test_output_concat, [
test_output_concat.shape[0] / self.batch_size,
self.batch_size
], '{}/{:02d}_test_output.jpg'.format(
self.sample_dir, step))
if np.mod(step, 20000) == 0:
self.Inception_score(sess, test_images, test_eye_pos, step)
self.FID_score(sess, test_images, test_eye_pos, step)
self.saver.save(
sess,
os.path.join(self.model_dir,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = self.saver.save(
sess,
os.path.join(self.model_dir, 'model_{:06d}.ckpt'.format(step)))
summary_writer.close()
coord.request_stop()
coord.join(threads)
print("Model saved in file: %s" % save_path)
def train(self):
self.t_vars = tf.trainable_variables()
self.dx_vars = [var for var in self.t_vars if 'Dx' in var.name]
self.dy_vars = [var for var in self.t_vars if 'Dy' in var.name]
self.gx_vars = [var for var in self.t_vars if 'Gx' in var.name]
self.gy_vars = [var for var in self.t_vars if 'Gy' in var.name]
self.e_vars = [var for var in self.t_vars if 'encode' in var.name]
self.gr_vars = [var for var in self.t_vars if 'Gr' in var.name]
# assert len(self.t_vars) == len(self.dx_vars + self.dy_vars + self.gx_vars
# + self.gy_vars + self.e_vars + self.gr_vars)
self.saver = tf.train.Saver()
self.p_saver = tf.train.Saver(self.gr_vars)
opti_Dx = tf.train.AdamOptimizer(self.opt.lr_d * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2). \
minimize(loss=self.Dx_loss, var_list=self.dx_vars)
opti_Dy = tf.train.AdamOptimizer(self.opt.lr_d * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2). \
minimize(loss=self.Dy_loss, var_list=self.dy_vars)
opti_Gx = tf.train.AdamOptimizer(self.opt.lr_g * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2). \
minimize(loss=self.Gx_loss, var_list=self.gx_vars)
opti_Gy = tf.train.AdamOptimizer(self.opt.lr_g * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2). \
minimize(loss=self.Gy_loss, var_list=self.gy_vars + self.e_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
start_step = 0
variables_to_restore = slim.get_variables_to_restore(
include=['vgg_16'])
restorer = tf.train.Saver(variables_to_restore)
restorer.restore(sess, self.opt.vgg_path)
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
self.saver.restore(sess, ckpt.model_checkpoint_path)
else:
try:
ckpt = tf.train.get_checkpoint_state(
self.opt.pretrain_path)
self.p_saver.restore(sess, ckpt.model_checkpoint_path)
except:
print(" Self-Guided Model path may not be correct")
# summary_op = tf.summary.merge_all()
# summary_writer = tf.summary.FileWriter(self.opt.log_dir, sess.graph)
step = start_step
lr_decay = 1
print("Start read dataset")
train_images_x, train_eye_pos_x, train_images_y, train_eye_pos_y, \
test_images, test_eye_pos = self.dataset.input()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
real_test_batch, real_test_pos = sess.run(
[test_images, test_eye_pos])
while step <= self.opt.niter:
if step > 20000 and step % 2000 == 0:
lr_decay = (self.opt.niter - step) / float(self.opt.niter -
20000)
x_data, x_p_data = sess.run([train_images_x, train_eye_pos_x])
y_data, y_p_data = sess.run([train_images_y, train_eye_pos_y])
xm_data, x_left_p_data, x_right_p_data = self.get_Mask_and_pos(
x_p_data)
ym_data, y_left_p_data, y_right_p_data = self.get_Mask_and_pos(
y_p_data)
f_d = {
self.x: x_data,
self.xm: xm_data,
self.x_left_p: x_left_p_data,
self.x_right_p: x_right_p_data,
self.y: y_data,
self.ym: ym_data,
self.y_left_p: y_left_p_data,
self.y_right_p: y_right_p_data,
self.lr_decay: lr_decay
}
sess.run(opti_Dx, feed_dict=f_d)
sess.run(opti_Dy, feed_dict=f_d)
sess.run(opti_Gx, feed_dict=f_d)
sess.run(opti_Gy, feed_dict=f_d)
if step % 500 == 0:
output_loss = sess.run([
self.Dx_loss + self.Dy_loss, self.Gx_loss,
self.Gy_loss, self.opt.lam_r * self.recon_loss_x,
self.opt.lam_r * self.recon_loss_y
],
feed_dict=f_d)
print(
"step %d D_loss=%.4f, Gx_loss=%.4f, Gy_loss=%.4f, Recon_loss_x=%.4f, Recon_loss_y=%.4f, lr_decay=%.4f"
%
(step, output_loss[0], output_loss[1], output_loss[2],
output_loss[3], output_loss[4], lr_decay))
if np.mod(step, 2000) == 0:
o_list = sess.run([
self.xl_left, self.xl_right, self.xc, self.xo,
self.yl_left, self.yl_right, self.yc, self.yo,
self.y2x, self.y2x_
],
feed_dict=f_d)
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_test_pos)
# for test
f_d = {
self.x: real_test_batch,
self.xm: batch_masks,
self.x_left_p: batch_left_eye_pos,
self.x_right_p: batch_right_eye_pos,
self.y: real_test_batch,
self.ym: batch_masks,
self.y_left_p: batch_left_eye_pos,
self.y_right_p: batch_right_eye_pos,
self.lr_decay: lr_decay
}
t_o_list = sess.run([self.xc, self.xo, self.yc, self.yo],
feed_dict=f_d)
train_trans = self.Transpose(
np.array([
x_data, o_list[2], o_list[3], o_list[6], o_list[7],
o_list[8], o_list[9]
]))
l_trans = self.Transpose(
np.array([o_list[0], o_list[1], o_list[4], o_list[5]]))
test_trans = self.Transpose(
np.array([
real_test_batch, t_o_list[0], t_o_list[1],
t_o_list[2], t_o_list[3]
]))
save_images(
l_trans,
'{}/{:02d}_lo_{}.jpg'.format(self.opt.sample_dir, step,
self.opt.exper_name))
save_images(
train_trans,
'{}/{:02d}_tr_{}.jpg'.format(self.opt.sample_dir, step,
self.opt.exper_name))
save_images(
test_trans,
'{}/{:02d}_te_{}.jpg'.format(self.opt.sample_dir, step,
self.opt.exper_name))
if np.mod(step, 20000) == 0:
self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
# summary_writer.close()
coord.request_stop()
coord.join(threads)
print("Model saved in file: %s" % save_path)
def test(self):
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
ckpt = tf.train.get_checkpoint_state(self.model_dir)
print('Load checkpoint')
if ckpt and ckpt.model_checkpoint_path:
print ckpt.model_checkpoint_path
self.saver.restore(sess, ckpt.model_checkpoint_path)
print('Load Succeed!')
else:
print('Do not exists any checkpoint,Load Failed!')
exit()
_, _, _, testbatch, testmask = self.dataset.input()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
batch_num = 1000 / self.batch_size
for j in range(batch_num):
real_test_batch, real_eye_pos = sess.run([testbatch, testmask])
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_eye_pos)
f_d = {
self.input: real_test_batch,
self.mask: batch_masks,
self.input_left_labels: batch_left_eye_pos,
self.input_right_labels: batch_right_eye_pos
}
for i in range(self.batch_size):
output = sess.run([self.input, self.new_recon_img],
feed_dict=f_d)
save_images(
np.reshape(output[0][i],
newshape=(1, self.output_size,
self.output_size, self.channel)),
[1, 1], '{}/{:02d}_{:2d}_input.jpg'.format(
self.testresult_dir + "4", j, i))
save_images(
np.reshape(output[1][i],
newshape=(1, self.output_size,
self.output_size, self.channel)),
[1, 1], '{}/{:02d}_{:2d}_recon.jpg'.format(
self.testresult_dir + "3", j, i))
save_images(
np.reshape(output[3][i],
newshape=(1, self.output_size / 2,
self.output_size / 2,
self.channel)), [1, 1],
'{}/{:02d}_{:2d}_recon_local_right.jpg'.format(
self.testresult_dir, j, i))
coord.request_stop()
coord.join(threads)
def test(self):
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
self.saver = tf.train.Saver()
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
print('Load checkpoint')
if ckpt and ckpt.model_checkpoint_path:
self.saver.restore(sess, ckpt.model_checkpoint_path)
print('Load Succeed!')
else:
print('Do not exists any checkpoint,Load Failed!')
exit()
trainbatch, trainmask, _, _, testbatch, testmask = self.dataset.input(
)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
batch_num = self.opt.test_num
for j in range(batch_num):
x_img, x_img_pos, y_img, y_img_pos = sess.run(
[trainbatch, trainmask, testbatch, testmask])
x_m, x_left_pos, x_right_pos = self.get_Mask_and_pos(x_img_pos)
y_m, y_left_pos, y_right_pos = self.get_Mask_and_pos(y_img_pos)
f_d = {
self.x: x_img,
self.xm: x_m,
self.x_left_p: x_left_pos,
self.x_right_p: x_right_pos,
self.y: y_img,
self.ym: y_m,
self.y_left_p: y_left_pos,
self.y_right_p: y_right_pos
}
output = sess.run([
self.x, self.xc, self.xo, self.yc, self.y, self.yo,
self.y2x, self.y2x_
],
feed_dict=f_d)
output_concat = self.Transpose(
np.array([
output[0], output[1], output[2], output[3], output[4],
output[5], output[6], output[7]
]))
local_output = sess.run([
self.xl_left, self.xl_right, self.yl_left, self.yl_right,
self._xl_left, self._xl_right, self._yl_left,
self._yl_right, self.y2x_left, self.y2x_right
],
feed_dict=f_d)
local_output_concat = self.Transpose(
np.array([
local_output[0], local_output[1], local_output[2],
local_output[3], local_output[4], local_output[5],
local_output[6], local_output[7], local_output[8],
local_output[9]
]))
inter_results = [
y_img,
np.ones(shape=[
self.opt.batch_size, self.opt.img_size,
self.opt.img_size, 3
])
]
inter_results1 = [
y_img,
np.ones(shape=[
self.opt.batch_size, self.opt.img_size,
self.opt.img_size, 3
])
]
inter_results2 = [
y_img,
np.ones(shape=[
self.opt.batch_size, self.opt.img_size,
self.opt.img_size, 3
])
]
inter_results3 = []
for i in range(0, 11):
f_d = {
self.x:
x_img,
self.xm:
x_m,
self.x_left_p:
x_left_pos,
self.x_right_p:
x_right_pos,
self.y:
y_img,
self.ym:
y_m,
self.y_left_p:
y_left_pos,
self.y_right_p:
y_right_pos,
self.alpha:
np.reshape([i / 10.0],
newshape=[self.opt.batch_size, 1])
}
output = sess.run(self._y2x_inter, feed_dict=f_d)
inter_results.append(output)
for i in range(0, 15):
f_d = {
self.x:
x_img,
self.xm:
x_m,
self.x_left_p:
x_left_pos,
self.x_right_p:
x_right_pos,
self.y:
y_img,
self.ym:
y_m,
self.y_left_p:
y_left_pos,
self.y_right_p:
y_right_pos,
self.alpha:
np.reshape([i / 10.0],
newshape=[self.opt.batch_size, 1])
}
output = sess.run(self._y2x_inter, feed_dict=f_d)
inter_results1.append(output)
for i in range(11, 22):
f_d = {
self.x:
x_img,
self.xm:
x_m,
self.x_left_p:
x_left_pos,
self.x_right_p:
x_right_pos,
self.y:
y_img,
self.ym:
y_m,
self.y_left_p:
y_left_pos,
self.y_right_p:
y_right_pos,
self.alpha:
np.reshape([i / 10.0],
newshape=[self.opt.batch_size, 1])
}
output = sess.run(self._y2x_inter, feed_dict=f_d)
inter_results2.append(output)
for i in range(-10, 0):
f_d = {
self.x:
x_img,
self.xm:
x_m,
self.x_left_p:
x_left_pos,
self.x_right_p:
x_right_pos,
self.y:
y_img,
self.ym:
y_m,
self.y_left_p:
y_left_pos,
self.y_right_p:
y_right_pos,
self.alpha:
np.reshape([i / 10.0],
newshape=[self.opt.batch_size, 1])
}
output = sess.run(self._y2x_inter, feed_dict=f_d)
inter_results3.append(output)
save_images(
output_concat,
'{}/{:02d}.jpg'.format(self.opt.test_sample_dir, j))
save_images(
local_output_concat,
'{}/{:02d}_local.jpg'.format(self.opt.test_sample_dir, j))
save_images(
self.Transpose(np.array(inter_results)),
'{}/{:02d}inter1.jpg'.format(self.opt.test_sample_dir, j))
save_images(
self.Transpose(np.array(inter_results1)),
'{}/{:02d}inter1_1.jpg'.format(self.opt.test_sample_dir,
j))
coord.request_stop()
coord.join(threads)
def train(self):
log_vars = []
log_vars.append(('D_loss', self.D_loss))
log_vars.append(('G_loss', self.G_loss))
vars = tf.trainable_variables()
'''
total_para = 0
for variable in vars:
shape = variable.get_shape()
print(variable.name, shape)
variable_para = 1
for dim in shape:
variable_para *= dim.value
total_para += variable_para
print("The total para", total_para)
'''
g_vars = getTrainVariable(vars, scope='encoder') + getTrainVariable(
vars, scope='decoder')
d_vars = getTrainVariable(vars, scope='discriminator')
assert len(vars) == len(g_vars) + len(d_vars)
saver = tf.train.Saver()
for k, v in log_vars:
tf.summary.scalar(k, v)
opti_G = tf.train.RMSPropOptimizer(
self.opt.lr_g * self.lr_decay).minimize(loss=self.G_loss,
var_list=g_vars)
opti_D = tf.train.RMSPropOptimizer(
self.opt.lr_g * self.lr_decay).minimize(loss=self.D_loss,
var_list=d_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(self.opt.log_dir,
sess.graph)
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
saver.restore(sess, ckpt.model_checkpoint_path)
print('Load Successfully!', ckpt.model_checkpoint_path)
else:
start_step = 0
step = start_step
lr_decay = 1
print("Start reading dataset")
while step <= self.opt.niter:
if step > self.opt.niter_decay and step % 2000 == 0:
lr_decay = (self.opt.niter - step
) / float(self.opt.niter - self.opt.iter_decay)
source_image_x_data, target_image_y1_data, cls_x, cls_y = self.data_ob.getNextBatch(
)
source_image_x = self.data_ob.getShapeForData(
source_image_x_data)
target_image_y1 = self.data_ob.getShapeForData(
target_image_y1_data)
f_d = {
self.x: source_image_x,
self.y_1: target_image_y1,
self.cls_x: cls_x,
self.cls_y: cls_y,
self.lr_decay: lr_decay
}
sess.run(opti_D, feed_dict=f_d)
sess.run(opti_G, feed_dict=f_d)
summary_str = sess.run(summary_op, feed_dict=f_d)
summary_writer.add_summary(summary_str, step)
if step % self.opt.display_freq == 0:
output_loss = sess.run([
self.D_loss, self.D_gan_loss, self.G_loss,
self.G_gan_loss, self.content_recon_loss,
self.feature_matching, self.l2_loss_d, self.l2_loss_g
],
feed_dict=f_d)
print(
"step %d, D_loss=%.4f, D_gan_loss=%.4f"
" G_loss=%.4f, G_gan_loss=%.4f, content_recon=%.4f, feautre_loss=%.4f, l2_loss=%.4f, lr_decay=%.4f"
%
(step, output_loss[0], output_loss[1], output_loss[2],
output_loss[3], output_loss[4], output_loss[5],
output_loss[6] + output_loss[7], lr_decay))
if np.mod(step, self.opt.save_latest_freq) == 0:
f_d = {self.x: source_image_x, self.y_1: target_image_y1}
train_output_img = sess.run(
[self.x, self.y_1, self.tilde_x, self.x_recon],
feed_dict=f_d)
output_img = np.concatenate(
[img for img in train_output_img[0:4]], axis=0)
save_images(
output_img, [
output_img.shape[0] / self.opt.batchSize,
self.opt.batchSize
], '{}/{:02d}_output_img.jpg'.format(
self.opt.sample_dir, step))
if np.mod(step, self.opt.save_model_freq) == 0 and step != 0:
saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
summary_writer.close()
print("Model saved in file: %s" % save_path)
def train(self):
opti_G = tf.train.RMSPropOptimizer(
self.g_learning_rate * self.lr_decay).minimize(
loss=self.G_loss,
var_list=self.encoder_vars + self.decoder_vars)
opti_D = tf.train.RMSPropOptimizer(self.d_learning_rate *
self.lr_decay).minimize(
loss=self.D_loss,
var_list=self.d_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
summary_op = tf.summary.merge_all()
summary_writer = tf.summary.FileWriter(self.log_dir, sess.graph)
ckpt = tf.train.get_checkpoint_state(self.write_model_path)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
self.saver.restore(sess, ckpt.model_checkpoint_path)
print(ckpt.model_checkpoint_path)
print('Load Successfully!')
else:
start_step = 0
step = start_step
lr_decay = 1
print("Start read dataset")
while step <= self.max_iters:
if step > 20000 and step % 2000 == 0:
lr_decay = (self.max_iters - step) / float(self.max_iters -
20000)
source_image_x_data, target_image_y1_data, target_image_y2_data, cls_x, cls_y = self.data_ob.getNextBatch(
)
source_image_x = self.data_ob.getShapeForData(
source_image_x_data)
target_image_y1 = self.data_ob.getShapeForData(
target_image_y1_data)
# cls_x = np.reshape(cls_x, newshape=[-1, 1])
# cls_y = np.reshape(cls_y, newshape=[-1, 1])
f_d = {
self.x: source_image_x,
self.y_1: target_image_y1,
self.cls_x: cls_x,
self.cls_y: cls_y,
self.lr_decay: lr_decay
}
sess.run(opti_D, feed_dict=f_d)
sess.run(opti_G, feed_dict=f_d)
summary_str = sess.run(summary_op, feed_dict=f_d)
summary_writer.add_summary(summary_str, step)
if step % 50 == 0:
output_loss = sess.run([
self.D_loss, self.D_gan_loss, self.G_loss,
self.G_gan_loss, self.content_recon_loss,
self.feature_matching
],
feed_dict=f_d)
print(
"step %d, D_loss=%.4f, D_gan_loss=%.4f"
" G_loss=%.4f, G_gan_loss=%.4f, content_recon=%.4f, feautre_loss=%.4f"
", lr_decay=%.4f" %
(step, output_loss[0], output_loss[1], output_loss[2],
output_loss[3], output_loss[4], output_loss[5],
lr_decay))
if np.mod(step, 1000) == 0:
f_d = {self.x: source_image_x, self.y_1: target_image_y1}
train_output_img = sess.run(
[self.x, self.y_1, self.tilde_x, self.x_recon],
feed_dict=f_d)
output_img = np.concatenate([
train_output_img[0], train_output_img[1],
train_output_img[2], train_output_img[3]
],
axis=0)
save_images(
output_img, [
output_img.shape[0] / self.batch_size,
self.batch_size
], '{}/{:02d}_output_img.jpg'.format(
self.sample_path, step))
if np.mod(step, 20000) == 0 and step != 0:
self.saver.save(
sess,
os.path.join(self.write_model_path,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = self.saver.save(
sess,
os.path.join(self.write_model_path,
'model_{:06d}.ckpt'.format(step)))
summary_writer.close()
print "Model saved in file: %s" % save_path
def train(self):
self.t_vars = tf.trainable_variables()
self.d_vars = [var for var in self.t_vars if 'D' in var.name]
self.g_vars = [var for var in self.t_vars if 'G' in var.name]
self.e_vars = [var for var in self.t_vars if 'encode' in var.name]
assert len(self.t_vars) == len(self.d_vars + self.g_vars + self.e_vars)
self.saver = tf.train.Saver()
self.p_saver = tf.train.Saver(self.e_vars)
opti_D = tf.train.AdamOptimizer(self.opt.lr_d * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2).\
minimize(loss=self.D_loss, var_list=self.d_vars)
opti_G = tf.train.AdamOptimizer(self.opt.lr_g * self.lr_decay, beta1=self.opt.beta1, beta2=self.opt.beta2).\
minimize(loss=self.G_loss, var_list=self.g_vars)
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init)
start_step = 0
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
if ckpt and ckpt.model_checkpoint_path:
start_step = int(
ckpt.model_checkpoint_path.split('model_',
2)[1].split('.', 2)[0])
self.saver.restore(sess, ckpt.model_checkpoint_path)
else:
print("")
# try:
# #self.p_saver.restore(sess, os.path.join(self.opt.pretrain_path,
# # 'model_{:06d}.ckpt'.format(100000)))
# except:
# print(" Self-Guided Model path may not be correct")
#summary_op = tf.summary.merge_all()
#summary_writer = tf.summary.FileWriter(self.opt.log_dir, sess.graph)
step = start_step
lr_decay = 1
print("Start read dataset")
image_path, train_images, train_eye_pos, test_images, test_eye_pos = self.dataset.input(
)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
print("Start entering the looping")
real_test_batch, real_test_pos = sess.run(
[test_images, test_eye_pos])
while step <= self.opt.niter:
if step > 20000 and step % 2000 == 0:
lr_decay = (self.opt.niter - step) / float(self.opt.niter -
20000)
real_batch_image_path, x_data, x_p_data = sess.run(
[image_path, train_images, train_eye_pos])
xm_data, x_left_p_data, x_right_p_data = self.get_Mask_and_pos(
x_p_data)
f_d = {
self.x: x_data,
self.xm: xm_data,
self.x_left_p: x_left_p_data,
self.x_right_p: x_right_p_data,
self.lr_decay: lr_decay
}
# optimize D
sess.run(opti_D, feed_dict=f_d)
# optimize G
sess.run(opti_G, feed_dict=f_d)
#summary_str = sess.run(summary_op, feed_dict=f_d)
#summary_writer.add_summary(summary_str, step)
if step % 500 == 0:
if self.opt.is_ss:
output_loss = sess.run([
self.D_loss, self.G_loss, self.opt.lam_r *
self.recon_loss, self.opt.lam_p * self.percep_loss,
self.r_cls_loss, self.f_cls_loss
],
feed_dict=f_d)
print(
"step %d D_loss=%.8f, G_loss=%.4f, Recon_loss=%.4f, Percep_loss=%.4f, "
"Real_class_loss=%.4f, Fake_class_loss=%.4f, lr_decay=%.4f"
% (step, output_loss[0], output_loss[1],
output_loss[2], output_loss[3], output_loss[4],
output_loss[5], lr_decay))
else:
output_loss = sess.run([
self.D_loss, self.G_loss, self.opt.lam_r *
self.recon_loss, self.opt.lam_p * self.percep_loss
],
feed_dict=f_d)
print(
"step %d D_loss=%.8f, G_loss=%.4f, Recon_loss=%.4f, Percep_loss=%.4f, lr_decay=%.4f"
% (step, output_loss[0], output_loss[1],
output_loss[2], output_loss[3], lr_decay))
if np.mod(step, 2000) == 0:
train_output_img = sess.run([
self.xl_left, self.xl_right, self.xc, self.yo, self.y,
self.yl_left, self.yl_right
],
feed_dict=f_d)
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_test_pos)
#for test
f_d = {
self.x: real_test_batch,
self.xm: batch_masks,
self.x_left_p: batch_left_eye_pos,
self.x_right_p: batch_right_eye_pos,
self.lr_decay: lr_decay
}
test_output_img = sess.run([self.xc, self.yo, self.y],
feed_dict=f_d)
output_concat = self.Transpose(
np.array([
x_data, train_output_img[2], train_output_img[3],
train_output_img[4]
]))
local_output_concat = self.Transpose(
np.array([
train_output_img[0], train_output_img[1],
train_output_img[5], train_output_img[6]
]))
test_output_concat = self.Transpose(
np.array([
real_test_batch, test_output_img[0],
test_output_img[2], test_output_img[1]
]))
save_images(
local_output_concat,
'{}/{:02d}_local_output.jpg'.format(
self.opt.sample_dir, step))
save_images(
output_concat,
'{}/{:02d}_output.jpg'.format(self.opt.sample_dir,
step))
save_images(
test_output_concat, '{}/{:02d}_test_output.jpg'.format(
self.opt.sample_dir, step))
if np.mod(step, 20000) == 0:
self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
step += 1
save_path = self.saver.save(
sess,
os.path.join(self.opt.checkpoints_dir,
'model_{:06d}.ckpt'.format(step)))
############################
#CREATING A TENSORBOARD BASED FILE FOR VISUALIZATION.
############################
from tensorflow.summary import FileWriter
# tf.train.import_meta_graph("checkpoints/model_100001.ckpt.meta")
FileWriter("__tb", sess.graph)
print("\n Graph File written\n")
#####################################
#Saving pb files: //Anant
#####################################
from tensorflow.python.tools import freeze_graph
#####################################
print("\n About to Freeze the graph\n")
filename = "saved_model"
directory = "log3_25_1"
pbtxt_filename = filename + '.pbtxt'
pbtxt_filepath = os.path.join(directory, pbtxt_filename)
pb_filepath = os.path.join(directory, filename + '.pb')
# This will only save the graph but the variables will not be saved.
# You have to freeze your model first.
tf.train.write_graph(graph_or_graph_def=sess.graph_def,
logdir=directory,
name=pbtxt_filename,
as_text=True)
# Freeze graph
# Method 1
# freeze_graph.freeze_graph(input_graph=pbtxt_filepath, input_saver='', input_binary=False, input_checkpoint=save_path, output_node_names='y', restore_op_name='save/restore_all', filename_tensor_name='save/Const:0', output_graph=pb_filepath, clear_devices=True, initializer_nodes='')
print("\n Graph frozen\n")
#summary_writer.close()
coord.request_stop()
coord.join(threads)
print("Model saved in file: %s \n" % save_path)
print("Saved_model saved in File: %s" % pb_filepath)
def test(self,
freeze_model,
num_custom_images,
flag_save_images=True,
custom_dataset=True):
init = tf.global_variables_initializer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
self.saver = tf.train.Saver()
with tf.Session(config=config) as sess:
sess.run(init)
ckpt = tf.train.get_checkpoint_state(self.opt.checkpoints_dir)
print('Load checkpoint')
if ckpt and ckpt.model_checkpoint_path:
self.saver.restore(sess, ckpt.model_checkpoint_path)
print('Load Succeed!')
else:
print('Do not exists any checkpoint,Load Failed!')
exit()
if custom_dataset == True:
batch_num = num_custom_images
testbatch, testmask = self.dataset.custom_test_input()
else:
batch_num = 3451 / self.opt.batch_size #Have made batch size = 1
_, _, _, testbatch, testmask = self.dataset.input()
#_,_,_, testbatch, testmask = self.dataset.input()
#testbatch, testmask = self.dataset.custom_test_input()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
#################################
# STARTING TIMING
##################################
start_time = time.time()
for j in range(int(batch_num)):
real_test_batch, real_eye_pos = sess.run([testbatch, testmask])
batch_masks, batch_left_eye_pos, batch_right_eye_pos = self.get_Mask_and_pos(
real_eye_pos)
f_d = {
self.x: real_test_batch,
self.xm: batch_masks,
self.x_left_p: batch_left_eye_pos,
self.x_right_p: batch_right_eye_pos
}
############################
# Saving the above 4 inputs consisting of Arrays to exportable files. Simply modify following things to load them:
# 'wb' -> 'rb'
# np.save -> var = np.load(file1)
# - ANANT
#############################
# with open('/disk/projectEyes/GazeCorrection/log3_25_1/array_vars/placeholder_1', 'wb') as file1:
# np.save(file1, batch_right_eye_pos)
# with open('/disk/projectEyes/GazeCorrection/log3_25_1/array_vars/placeholder', 'wb') as file1:
# np.save(file1, batch_left_eye_pos)
# with open('/disk/projectEyes/GazeCorrection/log3_25_1/array_vars/placeholder_3', 'wb') as file1:
# np.save(file1, batch_masks)
# with open('/disk/projectEyes/GazeCorrection/log3_25_1/array_vars/placeholder_2', 'wb') as file1:
# np.save(file1, real_test_batch)
# #Loading back the variables from files.
# with open('/disk/projectEyes/GazeCorrection/log3_25_1/array_vars/placeholder_2', 'rb') as file1:
# arr_plh1 = np.load(file1)
output = sess.run([self.x, self.y], feed_dict=f_d)
if flag_save_images == True:
#if j % 100 == 0 : #Considering the batch_num is 0
output_concat = self.Transpose(
np.array([output[0], output[1]]))
#save_images(output_concat, '{}/{:02d}.jpg'.format(self.opt.test_sample_dir, j))
######################
# IF ONLY RESULTANT IMAGE NEEDS TO BE SAVED W/O CONCATINATION:
# -ANANT
######################
# output_image = np.reshape(output[1], [256, 256, 3])
# save_images(output_image, '{}/out{}.jpg'.format("/disk/projectEyes/GazeCorrection/log3_25_1/test_sample_dir", j))
######################
# IF CONCAT OF INPUT + OUTPUT NEEDS TO BE SAVED:
# - ANANT
######################
save_images(
output_concat, '{}/{:02d}.jpg'.format(
"/disk/projectEyes/GazeCorrection/log3_25_1/test_sample_dir",
j))
#################################
# ENDING TIMING
##################################
print(
"\n \n INNER Time elapsed in GazeGan inference using TF of 3451 images = ",
time.time() - start_time)
if freeze_model == True:
############################
#CREATING A TENSORBOARD BASED FILE FOR VISUALIZATION.
############################
from tensorflow.summary import FileWriter
# tf.train.import_meta_graph("checkpoints/model_100001.ckpt.meta")
FileWriter("__tb_test", sess.graph)
print("\n Graph File written\n")
#####################################
#Saving pb files: //Anant
#####################################
from tensorflow.python.tools import freeze_graph
#####################################
print("\n About to Freeze the graph\n")
filename = "saved_model_test"
directory = "log3_25_1"
pbtxt_filename = filename + '.pbtxt'
pbtxt_filepath = os.path.join(directory, pbtxt_filename)
pb_filepath = os.path.join(directory, filename + '.pb')
tf.train.write_graph(graph_or_graph_def=sess.graph_def,
logdir=directory,
name=pbtxt_filename,
as_text=True)
#freeze_graph.freeze_graph(input_graph=pbtxt_filepath, input_saver='', input_binary=False, input_checkpoint=tf.train.latest_checkpoint(self.opt.checkpoints_dir), output_node_names='add', restore_op_name='save/restore_all', filename_tensor_name='save/Const:0', output_graph=pb_filepath, clear_devices=True, initializer_nodes='')
from tensorflow.python.framework import graph_io
frozen = tf.graph_util.convert_variables_to_constants(
sess, sess.graph_def, ["add"])
graph_io.write_graph(frozen,
'./log3_25_1/',
'inference_graph_3_batch1.pb',
as_text=False)
coord.request_stop()
coord.join(threads)
