def main():
# parse options
parser = TestOptions()
opts = parser.parse()
# data loader
print('\n--- load dataset ---')
datasetA = dataset_single(opts, 'A', opts.input_dim_a)
datasetB = dataset_single(opts, 'B', opts.input_dim_b)
if opts.a2b:
loader = torch.utils.data.DataLoader(datasetA,
batch_size=1,
num_workers=opts.nThreads)
loader_attr = torch.utils.data.DataLoader(datasetB,
batch_size=1,
num_workers=opts.nThreads,
shuffle=True)
else:
loader = torch.utils.data.DataLoader(datasetB,
batch_size=1,
num_workers=opts.nThreads)
loader_attr = torch.utils.data.DataLoader(datasetA,
batch_size=1,
num_workers=opts.nThreads,
shuffle=True)
# model
print('\n--- load model ---')
model = DRIT(opts)
model.setgpu(opts.gpu)
model.resume(opts.resume, train=False)
model.eval()
# directory
result_dir = os.path.join(opts.result_dir, opts.name)
if not os.path.exists(result_dir):
os.mkdir(result_dir)
# test
print('\n--- testing ---')
for idx1, img1 in enumerate(loader):
print('{}/{}'.format(idx1, len(loader)))
img1 = img1.cuda(opts.gpu)
imgs = [img1]
names = ['input']
for idx2, img2 in enumerate(loader_attr):
if idx2 == opts.num:
break
img2 = img2.cuda(opts.gpu)
with torch.no_grad():
if opts.a2b:
img = model.test_forward_transfer(img1, img2, a2b=True)
else:
img = model.test_forward_transfer(img2, img1, a2b=False)
imgs.append(img)
names.append('output_{}'.format(idx2))
save_imgs(imgs, names, os.path.join(result_dir, '{}'.format(idx1)))
return
def main():
# parse options
parser = TestOptions()
opts = parser.parse()
# data loader
print('\n--- load dataset ---')
if opts.a2b:
dataset = dataset_single(opts, 'A', opts.input_dim_a)
else:
dataset = dataset_single(opts, 'B', opts.input_dim_b)
loader = torch.utils.data.DataLoader(dataset,
batch_size=1,
num_workers=opts.nThreads)
# model
print('\n--- load model ---')
model = DivCo_DRIT(opts)
model.setgpu(opts.gpu)
model.resume(opts.resume, train=False)
model.eval()
# directory
result_dir = os.path.join(opts.result_dir, opts.name)
if not os.path.exists(result_dir):
os.mkdir(result_dir)
# test
print('\n--- testing ---')
ep_name = opts.resume.split('/')[-1].split('.')[0]
for idx1, (img1, name1) in enumerate(loader):
print('{}/{}'.format(idx1, len(loader)))
img1 = img1.cuda()
imgs = [img1]
names = ['input']
for idx2 in range(opts.num):
with torch.no_grad():
if opts.random:
img = model.test_forward(img1, a2b=opts.a2b)
else:
latent = float(idx2) / (opts.num - 1) * 2 - 1
img = model.test_givenz_forward(img1, latent, a2b=opts.a2b)
imgs.append(img)
names.append('output_{}'.format(idx2))
save_imgs(
imgs, names,
os.path.join(
result_dir, 'test_ep{}_num{}_a2b{}_random{}'.format(
ep_name, opts.num, opts.a2b, int(opts.random)),
name1[0].split('.')[0]))
return
def main():
# parse options
parser = TestOptions()
opts = parser.parse()
# data loader
print('\n--- load dataset ---')
if opts.a2b:
dataset = dataset_single(opts, 'A', opts.input_dim_a)
subdir = "a2b"
else:
dataset = dataset_single(opts, 'B', opts.input_dim_b)
subdir = "b2a"
loader = torch.utils.data.DataLoader(dataset, batch_size=1, num_workers=opts.nThreads)
# model
print('\n--- load model ---')
model = DRIT(opts)
model.setgpu(opts.gpu)
model.resume(opts.resume, train=False)
model.eval()
# directory
result_dir = os.path.join(opts.result_dir, opts.name, subdir)
if not os.path.exists(result_dir):
os.makedirs(result_dir)
# test
print('\n--- testing ---')
for idx1, img1 in enumerate(loader):
print('{}/{}'.format(idx1, len(loader)))
img1 = img1.cuda()
imgs = [img1]
names = ['input']
for idx2 in range(opts.num):
with torch.no_grad():
img = model.test_forward(img1, a2b=opts.a2b)
imgs.append(img)
names.append('output_{}'.format(idx2))
save_imgs(imgs, names, os.path.join(result_dir, '{}'.format(idx1)))
return
def main():
# parse options
parser = TestOptions()
opts = parser.parse()
# data loader
print('\n--- load dataset ---')
datasetA = dataset_single(opts, 'A', opts.input_dim_a)
datasetB = dataset_single(opts, 'B', opts.input_dim_b)
if opts.a2b:
loader = torch.utils.data.DataLoader(datasetA,
batch_size=1,
num_workers=opts.nThreads)
loader_attr = torch.utils.data.DataLoader(datasetB,
batch_size=1,
num_workers=opts.nThreads,
shuffle=True)
else:
loader = torch.utils.data.DataLoader(datasetB,
batch_size=1,
num_workers=opts.nThreads)
loader_attr = torch.utils.data.DataLoader(datasetA,
batch_size=1,
num_workers=opts.nThreads,
shuffle=True)
# model
print('\n--- load model ---')
model = DRIT(opts)
model.setgpu(opts.gpu)
model.resume(opts.resume, train=False)
model.eval()
# directory
result_dir = os.path.join(opts.result_dir, opts.name)
if not os.path.exists(result_dir):
os.mkdir(result_dir)
# test
print('\n--- testing ---')
for idx1, (img1, img1_path) in enumerate(loader):
print('{}/{}'.format(idx1, len(loader)))
img1_path = img1_path[0]
img1_prefix = os.path.basename(img1_path).split('.')[0]
# print('img1_prefix:', img1_prefix)
img1 = img1.cuda()
imgs = [img1]
# print('img1 type:', type(img1))
names = [f'{img1_prefix}_input']
for idx2, (img2, img2_path) in enumerate(loader_attr):
img2_path = img2_path[0]
img2_prefix = os.path.basename(img2_path).split('.')[0]
# print('img2_prefix:', img2_prefix)
if img1_prefix == img2_prefix:
img2 = img2.cuda()
imgs.append(img2)
names.append(f'{img2_prefix}_real')
# print('img2 type:', type(img2))
with torch.no_grad():
if opts.a2b:
img = model.test_forward_transfer(img1, img2, a2b=True)
else:
img = model.test_forward_transfer(img2,
img1,
a2b=False)
imgs.append(img)
names.append(f'{img2_prefix}_fake')
break
save_imgs(imgs, names, result_dir)
return
def main():
# parse options
opt = TestOptions().parse()
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
# data loader
print('\n--- load dataset ---')
#if opt.a2b:
dataset = dataset_single(opt, 'A')
#else:
#dataset = dataset_single(opt, 'B')
loader = torch.utils.data.DataLoader(dataset, batch_size=1, num_workers=8)
file_name = opt.fid
data_mu = np.load(file_name)['mu']
data_sigma = np.load(file_name)['sigma']
# Load inception net
print('\n--- load inception net ---')
block_idx = InceptionV3.BLOCK_INDEX_BY_DIM[2048]
model_inception = InceptionV3([block_idx]).cuda()
model_inception.eval() # set to eval mode
## Initializing the AlexNet model
model_alexnet = modelss.PerceptualLoss(model='net-lin',
net='alex',
use_gpu=True)
transform = torchvision.transforms.Compose([
torchvision.transforms.ToPILImage(),
torchvision.transforms.Resize(64),
torchvision.transforms.ToTensor()
])
# Load pre-trained model
print('\n--- load model ---')
model = create_model(opt)
all_files = np.arange(200, 210, 10).tolist()
torch.manual_seed(8)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(8)
test_sample = 1
for epoch in all_files:
model.load_networks(epoch)
model.eval()
# generate images & accumulate inception activation
pool1 = []
pool2 = []
dists = []
for idx1, img1 in enumerate(loader):
img = img1.cuda()
imgs = [img]
names = ['input']
with torch.no_grad():
img = model.test_forward(img, a2b=True)
imgs = [img]
imgss = []
# accumulate inception activation for FID1
assert (torch.max(img) <= 1.0 and torch.min(img) >= -1.0)
pool_val = model_inception(img)[0] # bs x 2048 x 1 x 1
assert (pool_val.size(1) == 2048 and pool_val.size(2) == 1
and pool_val.size(3) == 1)
pool_val = pool_val.squeeze()
pool1 += [np.asarray(pool_val.cpu())]
for i in range(1):
img = model.test_forward(img, a2b=False)
img = model.test_forward(img, a2b=True)
imgs += [img]
# accumulate inception activation for FID2
assert (torch.max(img) <= 1.0 and torch.min(img) >= -1.0)
pool_val = model_inception(img)[0] # bs x 2048 x 1 x 1
assert (pool_val.size(1) == 2048 and pool_val.size(2) == 1
and pool_val.size(3) == 1)
pool_val = pool_val.squeeze()
pool2 += [np.asarray(pool_val.cpu())]
# test lpips on 4 (1+1+2) generated images
for i in range(2):
img = model.test_forward(img, a2b=False)
img = model.test_forward(img, a2b=True)
imgs += [img]
for i in imgs:
imgss.append(transform(i[0].cpu()).cuda())
dist = compute_lpips(imgss, model_alexnet)
dists.append(dist)
# compute fid score
lpips_score = sum(dists) / len(dists)
print('LPIPS score for epoch %d is %f ' % (epoch, lpips_score))
pool1 = np.vstack(pool1)
mu, sigma = np.mean(pool1, axis=0), np.cov(pool1, rowvar=False)
FID1 = inception_utils.numpy_calculate_frechet_distance(
mu, sigma, data_mu, data_sigma)
print('FID1 score for epoch %d is %f ' % (epoch, FID1))
pool2 = np.vstack(pool2)
mu, sigma = np.mean(pool2, axis=0), np.cov(pool2, rowvar=False)
FID2 = inception_utils.numpy_calculate_frechet_distance(
mu, sigma, data_mu, data_sigma)
print('FID2 score for epoch %d is %f ' % (epoch, FID2))
def main():
# parse options
parser = TestOptions()
opts = parser.parse()
result_dir = os.path.join(opts.result_dir, opts.name)
orig_dir = opts.orig_dir
blur_dir = opts.dataroot
if not os.path.exists(result_dir):
os.mkdir(result_dir)
# data loader
print('\n--- load dataset ---')
if opts.a2b:
dataset = dataset_single(opts, 'A', opts.input_dim_a)
else:
dataset = dataset_single(opts, 'B', opts.input_dim_b)
loader = torch.utils.data.DataLoader(dataset, batch_size=1, num_workers=opts.nThreads)
# model
print('\n--- load model ---')
model = UID(opts)
model.setgpu(opts.gpu)
model.resume(opts.resume, train=False)
model.eval()
# test
print('\n--- testing ---')
for idx1, (img1,img_name) in enumerate(loader):
print('{}/{}'.format(idx1, len(loader)))
img1 = img1.cuda(opts.gpu).detach()
with torch.no_grad():
img = model.test_forward(img1, a2b=opts.a2b)
img_name = img_name[0].split('/')
img_name = img_name[-1]
save_imgs(img, img_name, result_dir)
# evaluate metrics
if opts.percep == 'default':
pLoss = PerceptualLoss(nn.MSELoss(),p_layer=36)
elif opts.percep == 'face':
self.perceptualLoss = networks.PerceptualLoss16(nn.MSELoss(),p_layer=30)
else:
self.perceptualLoss = networks.MultiPerceptualLoss(nn.MSELoss())
orig_list = sorted(os.listdir(orig_dir))
deblur_list = sorted(os.listdir(result_dir))
blur_list = sorted(os.listdir(blur_dir))
psnr = []
ssim = []
percp = []
blur_psnr = []
blur_ssim = []
blur_percp = []
for (deblur_img_name, orig_img_name, blur_img_name) in zip(deblur_list, orig_list, blur_list):
deblur_img_name = os.path.join(result_dir,deblur_img_name)
orig_img_name = os.path.join(orig_dir,orig_img_name)
blur_img_name = os.path.join(blur_dir, blur_img_name)
deblur_img = imread(deblur_img_name)
orig_img = imread(orig_img_name)
blur_img = imread(blur_img_name)
try:
psnr.append(PSNR(deblur_img, orig_img))
ssim.append(SSIM(deblur_img, orig_img, multichannel=True))
blur_psnr.append(PSNR(blur_img, orig_img))
blur_ssim.append(SSIM(blur_img, orig_img, multichannel=True))
except ValueError:
print(orig_img_name)
with torch.no_grad():
temp = pLoss.getloss(deblur_img,orig_img)
temp2 = pLoss.getloss(blur_img,orig_img)
percp.append(temp)
blur_percp.append(temp2)
print(sum(psnr)/len(psnr))
print(sum(ssim)/len(ssim))
print(sum(percp)/len(percp))
print(sum(blur_psnr)/len(psnr))
print(sum(blur_ssim)/len(ssim))
print(sum(blur_percp)/len(percp))
return
