def reconstruction(self, volatile=True):
# volatile : no back gradient.
self.x = Variable(self.input, volatile=volatile)
# Before call self.decoder, normal_z must be set.
self.reconstruct_x = Variable(self.input, volatile=volatile)
# import numpy as np
# print(np.shape(self.x))
for xx in range(2):
for ii in range(3):
for jj in range(32):
for kk in range(16):
self.reconstruct_x[xx, ii, jj, kk] = self.x[xx, ii, jj, kk]
for i in range(20):
self.z = self.encoder(self.reconstruct_x)
self.reconstruct_x = self.decoder(self.z)
for xx in range(2):
for ii in range(3):
for jj in range(32):
for kk in range(16):
self.reconstruct_x[xx, ii, jj, kk] = self.x[xx, ii, jj, kk]
reconstruct_x = tensor2im(self.reconstruct_x.data, sample_single_image=False)
real_x = tensor2im(self.input.data, sample_single_image=False)
return OrderedDict([('real_x', real_x), ('reconstruct_x', reconstruct_x)])
def get_infervisuals(self, infernum, sample_single_image=True):
# volatile : no back gradient.
self.x = Variable(self.input, volatile=True)
self.infer_x = Variable(self.input, volatile=True)
for i in range(infernum):
print(i)
self.infer_z = self.encoder(self.infer_x)
self.infer_x = self.decoder(self.infer_z)
self.sampled_z = self.encoder(self.infer_x)
# ------------------------------
infer_x = tensor2im(self.infer_x.data, sample_single_image=sample_single_image)
real_x = tensor2im(self.x.data, sample_single_image=sample_single_image)
return OrderedDict([('real_x', real_x), ('infer_x', infer_x)])
def reconstruction(self, volatile=True):
# volatile : no back gradient.
self.x = Variable(self.input, volatile=volatile)
self.reconstruct_x = Variable(self.input, volatile=volatile)
for i in range(self.sampling_count):# sampling_count=20
self.z = self.encoder(self.reconstruct_x)
self.reconstruct_x = self.decoder(self.z)
for xx in range(self.batch_size):
for ii in range(3):
for jj in range(32):
for kk in range(16):
self.reconstruct_x[xx, ii, jj, kk] = self.x[xx, ii, jj, kk]
reconstruct_x = tensor2im(self.reconstruct_x.data, sample_single_image=False)
real_x = tensor2im(self.input.data, sample_single_image=False)
return OrderedDict([('real_x', real_x), ('reconstruct_x', reconstruct_x)])
def save_images(webpage, visuals, image_path, aspect_ratio=1.0, width=256):
"""Save images to the disk.
Parameters:
webpage (the HTML class) -- the HTML webpage class that stores these imaegs (see html.py for more details)
visuals (OrderedDict) -- an ordered dictionary that stores (name, images (either tensor or numpy) ) pairs
image_path (str) -- the string is used to create image paths
aspect_ratio (float) -- the aspect ratio of saved images
width (int) -- the images will be resized to width x width
This function will save images stored in 'visuals' to the HTML file specified by 'webpage'.
"""
image_dir = webpage.get_image_dir()
short_path = ntpath.basename(image_path[0])
name = os.path.splitext(short_path)[0]
webpage.add_header(name)
ims, txts, links = [], [], []
for label, im_data in visuals.items():
im = util.tensor2im(im_data)
image_name = '%s_%s.png' % (name, label)
save_path = os.path.join(image_dir, image_name)
util.save_image(im, save_path, aspect_ratio=aspect_ratio)
ims.append(image_name)
txts.append(label)
links.append(image_name)
webpage.add_images(ims, txts, links, width=width)
def get_current_visuals(self):
input_B1 = utils.tensor2im(self.input_B1)
input_B2 = utils.tensor2im(self.input_B2)
output_B1_S = utils.tensor2im(self.output['B1_S'])
output_B1_E = utils.tensor2im(self.output['B1_E'])
output_B2_S = utils.tensor2im(self.output['B2_S'])
output_B2_E = utils.tensor2im(self.output['B2_E'])
return OrderedDict([('B1',input_B1),('B2',input_B2),('B1_S',output_B1_S),
('B1_E',output_B1_E),('B2_S',output_B2_S),('B2_E',output_B2_E)])
def save_test_images(self, idx):
save_image(tensor2im(self.real_A),
self.opt.img_save_path + f"/img_{idx:04d}_real_A.png")
save_image(tensor2im(self.rec_A),
self.opt.img_save_path + f"/img_{idx:04d}_rec_A.png")
save_image(tensor2im(self.fake_B),
self.opt.img_save_path + f"/img_{idx:04d}_trans_A2B.png")
save_image(tensor2im(self.real_B),
self.opt.img_save_path + f"/img_{idx:04d}_real_B.png")
save_image(tensor2im(self.rec_B),
self.opt.img_save_path + f"/img_{idx:04d}_rec_B.png")
save_image(tensor2im(self.fake_A),
self.opt.img_save_path + f"/img_{idx:04d}_trans_B2A.png")
def save_train_images(self, epoch):
save_image(tensor2im(self.real_A),
self.opt.img_save_path + f"/real_A_epoch_{epoch}.png")
save_image(tensor2im(self.real_B),
self.opt.img_save_path + f"/real_B_epoch_{epoch}.png")
save_image(tensor2im(self.rec_A),
self.opt.img_save_path + f"/rec_A_epoch_{epoch}.png")
save_image(tensor2im(self.rec_B),
self.opt.img_save_path + f"/rec_B_epoch_{epoch}.png")
save_image(tensor2im(self.idt_A),
self.opt.img_save_path + f"/idt_A_epoch_{epoch}.png")
save_image(tensor2im(self.idt_B),
self.opt.img_save_path + f"/idt_B_epoch_{epoch}.png")
def get_current_visuals(self):
inp_img = util.tensor2im(self.input, 'img')
target_img = util.tensor2im(self.target, 'lbl')
seg_img = util.tensor2im(self.pred_seg, 'lbl')
return OrderedDict([('out_S', seg_img), ('inp_S', inp_img),
('target_S', target_img)])
def get_visuals(self, sample_single_image=True):
fake_x = tensor2im(self.sampled_x.data, sample_single_image=sample_single_image)
real_x = tensor2im(self.x.data, sample_single_image=sample_single_image)
return OrderedDict([('real_x', real_x), ('fake_x', fake_x)])
def get_visuals(self, sample_single_image=True):
image_input = tensor2im(self.input, sample_single_image=sample_single_image)
return OrderedDict([('input', image_input)])
def get_visuals(self, sample_single_image=True):
fake_x = tensor2im(self.sampled_x.data, sample_single_image=sample_single_image)
real_x = tensor2im(self.x.data, sample_single_image=sample_single_image)
return OrderedDict([('real_x', real_x), ('fake_x', fake_x)])
