def test(self):
torch.set_grad_enabled(False)
epoch = self.optimizer.get_last_epoch()
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, len(self.loader_test),
len(self.scale)))
self.model.eval()
timer_test = utility.timer()
if self.args.save_results: self.ckp.begin_background()
for idx_data, d in enumerate(self.loader_test):
for idx_scale, scale in enumerate(self.scale):
d.dataset.set_scale(idx_scale)
ssim_result = 0.
for lr, hr, filename in tqdm(d, ncols=80):
lr, hr = self.prepare(lr, hr)
torch.cuda.empty_cache()
sr = self.model(lr, idx_scale)
sr = utility.quantize(sr, self.args.rgb_range)
save_list = [sr]
self.ckp.log[-1, idx_data, idx_scale] += utility.calc_psnr(
sr, hr, scale, self.args.rgb_range, dataset=d)
if self.args.test_only:
ssim_result += utility.calc_ssim(sr,
hr,
scale,
self.args.rgb_range,
dataset=d)
if self.args.save_gt:
save_list.extend([lr, hr])
if self.args.save_results:
self.ckp.save_results(d, filename[0], save_list, scale)
self.ckp.log[-1, idx_data, idx_scale] /= len(d)
ssim_result /= len(d)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}]\tPSNR: {:.3f} (Best: {:.3f} @epoch {})\tSSIM: {:.4f}'
.format(d.dataset.name, scale, self.ckp.log[-1, idx_data,
idx_scale],
best[0][idx_data, idx_scale],
best[1][idx_data, idx_scale] + 1, ssim_result))
self.ckp.write_log('Forward: {:.2f}s\n'.format(timer_test.toc()))
self.ckp.write_log('Saving...')
if self.args.save_results:
self.ckp.end_background()
if not self.args.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0, 0] + 1 == epoch))
self.ckp.write_log('Total: {:.2f}s\n'.format(timer_test.toc()),
refresh=True)
torch.set_grad_enabled(True)
def test(self):
epoch = self.scheduler.last_epoch + 1
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, len(self.scale)))
self.model.eval()
timer_test = utility.timer()
device = torch.device('cpu' if self.args.cpu else 'cuda')
with torch.no_grad():
for idx_scale, scale in enumerate(self.scale):
eval_acc = 0
eval_acc_ssim = 0
self.loader_test.dataset.set_scale(idx_scale)
###san是没有注释的：
#tqdm_test = tqdm(self.loader_test, ncols=80)
###和san不同：
for idx_img, (lr, hr, filename,
_) in enumerate(self.loader_test):
filename = filename[0]
no_eval = (hr.nelement() == 1)
if not no_eval:
lr, hr = self.prepare(lr, hr)
else:
lr, = self.prepare(lr)
N, C, H, W = lr.size()
scale = self.args.scale[idx_scale]
outH, outW = int(H * scale), int(W * scale)
#_,_,outH,outW = hr.size()
#timer_test.tic()
scale_coord_map, mask = self.input_matrix_wpn_new(
H, W, self.args.scale[idx_scale])
#position, mask = self.pos_matrix(H,W,self.args.scale[idx_scale])
#print(timer_test.toc())
if self.args.n_GPUs > 1 and not self.args.cpu:
scale_coord_map = torch.cat([scale_coord_map] *
self.args.n_GPUs, 0)
else:
scale_coord_map = scale_coord_map.to(device)
timer_test.tic()
sr = self.model(lr, idx_scale, scale_coord_map)
timer_test.hold()
re_sr = torch.masked_select(sr, mask.to(device))
sr = re_sr.contiguous().view(N, C, outH, outW)
sr = utility.quantize(sr, self.args.rgb_range)
#timer_test.hold()
save_list = [sr]
#???
print("no_eval:")
print(no_eval)
if not no_eval:
eval_acc += utility.calc_psnr(
sr,
hr,
scale,
self.args.rgb_range,
benchmark=self.loader_test.dataset.benchmark)
eval_acc_ssim += utility.calc_ssim(
sr,
hr,
scale,
benchmark=self.loader_test.dataset.benchmark)
save_list.extend([lr, hr])
if self.args.save_results:
a = 1
self.ckp.save_results(filename, save_list, scale)
###
self.ckp.log[-1, idx_scale] = eval_acc / len(self.loader_test)
best = self.ckp.log.max(0)
# print(timer_test.acc/100)
self.ckp.write_log(
'[{} x{}]\tPSNR: {:.3f} SSIM: {:.4f} (Best: {:.3f} @epoch {})'
.format(self.args.data_test, scale,
self.ckp.log[-1, idx_scale],
eval_acc_ssim / len(self.loader_test),
best[0][idx_scale], best[1][idx_scale] + 1))
#???
print(
'[{} x{}]\tPSNR: {:.3f} SSIM: {:.4f} (Best: {:.3f} @epoch {})'
.format(self.args.data_test, scale,
self.ckp.log[-1, idx_scale],
eval_acc_ssim / len(self.loader_test),
best[0][idx_scale], best[1][idx_scale] + 1))
print("psnr")
print(eval_acc / len(self.loader_test))
self.ckp.write_log('Total time: {:.2f}s\n'.format(timer_test.toc()),
refresh=True)
if not self.args.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0] + 1 == epoch))
def test(self):
epoch = self.optimizer.get_last_epoch()
torch.set_grad_enabled(False)
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, len(self.loader_test),
len(self.scale)))
self.model.eval()
timer_test = utility.timer()
if self.args.save_results: self.ckp.begin_background()
for idx_data, d in enumerate(self.loader_test):
for idx_scale, scale in enumerate(self.scale):
d.dataset.set_scale(idx_scale)
for lr, hr, filename in tqdm(d, ncols=80):
lr, hr = self.prepare(lr, hr)
sr = self.model(lr, idx_scale)
sr = utility.quantize(sr, self.args.rgb_range)
if self.args.guided_filtering:
sr_cpu = sr.squeeze().permute(
1, 2, 0).detach().cpu().numpy()
sr_cpu = sr_cpu.astype(np.uint8)
if self.args.guided_type == 'RGB':
guide = sr_cpu
elif self.args.guided_type == 'Gray':
guide = cv2.cvtColor(sr_cpu, cv2.COLOR_RGB2GRAY)
elif self.args.guided_type == 'Ycbcr':
guide = cv2.cvtColor(sr_cpu, cv2.COLOR_BGR2YCR_CB)
guide = guide[:, :, 0]
elif self.args.guided_type == 'HSV':
guide = cv2.cvtColor(sr_cpu, cv2.COLOR_RGB2HSV)
# sr_cpu = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
else:
guide = sr_cpu
guided_img = guidedFilter(guide, sr_cpu,
self.args.guided_radius,
self.args.guided_eps)
sr = torch.from_numpy(guided_img).permute(
2, 0, 1).unsqueeze(0).float().to(sr.device)
save_list = [sr]
self.ckp.log[
-1, idx_data, idx_scale] += 0.5 * utility.calc_psnr(
sr, hr, scale, self.args.rgb_range, dataset=d
) / 50. + 0.5 * (utility.calc_ssim(
sr, hr, scale, self.args.rgb_range) - 0.4) / 0.6
if self.args.save_gt:
save_list.extend([lr, hr])
if self.args.save_results:
self.ckp.save_results(d, filename[0], save_list, scale)
self.ckp.log[-1, idx_data, idx_scale] /= len(d)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}]\tScore: {:.6f} (Best: {:.6f} @epoch {})'.format(
d.dataset.name, scale, self.ckp.log[-1, idx_data,
idx_scale],
best[0][idx_data,
idx_scale], best[1][idx_data, idx_scale] + 1))
self.ckp.write_log('Forward: {:.2f}s\n'.format(timer_test.toc()))
self.ckp.write_log('Saving...')
if self.args.save_results:
self.ckp.end_background()
if not self.args.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0, 0] + 1 == epoch))
self.ckp.write_log('Total: {:.2f}s\n'.format(timer_test.toc()),
refresh=True)
torch.set_grad_enabled(True)
def test(self):
torch.set_grad_enabled(False)
epoch = self.optimizer.get_last_epoch()
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(
torch.zeros(1, len(self.loader_test), len(self.scale))
)
self.model.eval()
timer_test = utility.timer()
if self.args.save_results: self.ckp.begin_background()
for idx_data, d in enumerate(self.loader_test):
for idx_scale, scale in enumerate(self.scale):
eval_ssim = 0
d.dataset.set_scale(idx_scale)
for lr, hr, filename, _ in tqdm(d, ncols=80):
lr, hr = self.prepare(lr, hr)
sr = self.model(lr, idx_scale)
sr = utility.quantize(sr, self.args.rgb_range)
save_list = [sr]
self.ckp.log[-1, idx_data, idx_scale] += utility.calc_psnr(
sr, hr, scale, self.args.rgb_range, dataset=d
)
eval_ssim += utility.calc_ssim(sr, hr, window_size = 11, size_average = True)
#eval_ssim += skimage.measure.compare_ssim(sr, hr, win_size=11, data_range=255, multichannel=True, gaussian_weights=True)
if self.args.save_gt:
save_list.extend([lr, hr])
if self.args.save_results:
self.ckp.save_results(d, filename[0], save_list, scale)
self.ckp.log[-1, idx_data, idx_scale] /= len(d)
mean_ssim = eval_ssim / len(d)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}]\tPSNR: {:.4f} SSIM：{:.4f} (Best: {:.4f} @epoch {})'.format(
d.dataset.name,
scale,
self.ckp.log[-1, idx_data, idx_scale],
mean_ssim,
best[0][idx_data, idx_scale],
best[1][idx_data, idx_scale] + 1
)
)
self.ckp.write_log('Forward: {:.2f}s\n'.format(timer_test.toc()))
self.ckp.write_log('Saving...')
if self.args.save_results:
self.ckp.end_background()
if not self.args.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0, 0] + 1 == epoch))
self.ckp.write_log(
'Total: {:.2f}s\n'.format(timer_test.toc()), refresh=True
)
torch.set_grad_enabled(True)
def test(self):
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, len(self.scale)))
self.model.eval()
timer_test = utility.timer()
with torch.no_grad():
for idx_scale, scale in enumerate(self.scale):
self.loader_test.dataset.set_scale(idx_scale)
eval_psnr = 0
eval_ssim = 0
degrade = util.SRMDPreprocessing(
self.scale[0],
kernel_size=self.args.blur_kernel,
blur_type=self.args.blur_type,
sig=self.args.sig,
lambda_1=self.args.lambda_1,
lambda_2=self.args.lambda_2,
theta=self.args.theta,
noise=self.args.noise)
for idx_img, (hr, filename, _) in enumerate(self.loader_test):
hr = hr.cuda() # b, 1, c, h, w
hr = self.crop_border(hr, scale)
lr, _ = degrade(hr, random=False) # b, 1, c, h, w
hr = hr[:, 0, ...] # b, c, h, w
# inference
timer_test.tic()
sr = self.model(lr[:, 0, ...])
timer_test.hold()
sr = utility.quantize(sr, self.args.rgb_range)
hr = utility.quantize(hr, self.args.rgb_range)
# metrics
eval_psnr += utility.calc_psnr(
sr,
hr,
scale,
self.args.rgb_range,
benchmark=self.loader_test.dataset.benchmark)
eval_ssim += utility.calc_ssim(
sr,
hr,
scale,
benchmark=self.loader_test.dataset.benchmark)
# save results
if self.args.save_results:
save_list = [sr]
filename = filename[0]
self.ckp.save_results(filename, save_list, scale)
self.ckp.log[-1, idx_scale] = eval_psnr / len(self.loader_test)
self.ckp.write_log(
'[Epoch {}---{} x{}]\tPSNR: {:.3f} SSIM: {:.4f}'.format(
self.args.resume,
self.args.data_test,
scale,
eval_psnr / len(self.loader_test),
eval_ssim / len(self.loader_test),
))
def test(self):
epoch = self.scheduler.last_epoch
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, len(self.scale)))
self.model.eval()
timer_test = utility.timer()
with torch.no_grad():
for idx_scale, scale in enumerate(self.scale):
eval_acc = 0
ssim = 0
self.loader_test.dataset.set_scale(idx_scale)
tqdm_test = tqdm(self.loader_test, ncols=80)
for idx_img, (lr, hr, filename, _) in enumerate(tqdm_test):
filename = filename[0]
no_eval = (hr.nelement() == 1)
if not no_eval:
lr, hr = self.prepare([lr, hr])
else:
lr = self.prepare([lr])[0]
sr = self.model(lr, idx_scale)
sr = utility.quantize(sr, self.args.rgb_range)
save_list = [sr]
if not no_eval:
eval_acc += utility.calc_psnr(
sr,
hr,
scale,
self.args.rgb_range,
)
if self.args.test_only:
ssim += utility.calc_ssim(
sr,
hr,
scale,
self.args.rgb_range,
)
if self.args.save_results:
self.ckp.save_results_nopostfix(
filename, save_list, scale, epoch)
self.ckp.log[-1, idx_scale] = eval_acc / len(self.loader_test)
ssim_avg = ssim / len(self.loader_test)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}]\tPSNR: {:.3f} (Best: {:.3f} @epoch {})'.format(
self.args.data_test, scale, self.ckp.log[-1,
idx_scale],
best[0][idx_scale], best[1][idx_scale] + 1))
self.ckp.write_log('[{} x{}]\tSSIM: {:.3f}'.format(
self.args.data_test, scale, ssim_avg))
self.ckp.write_log('Total time: {:.2f}s, ave time: {:.2f}s\n'.format(
timer_test.toc(),
timer_test.toc() / len(self.loader_test)),
refresh=True)
if not self.args.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0] + 1 == epoch))
def test(self):
# torch.set_grad_enabled(False)
with torch.no_grad():
epoch = self.optimizer.get_last_epoch()
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(
torch.zeros(1, 2, len(self.loader_test),
len(self.args.test_scale)))
self.model.eval()
# self.model = self.model.to('cpu')
timer_test = utility.timer()
if self.args.save_results: self.ckp.begin_background()
for idx_data, d in enumerate(self.loader_test):
for idx_scale, scale in enumerate(self.args.test_scale):
d.dataset.set_scale(idx_scale)
for lr, hr, filename in tqdm(d, ncols=80):
lr = lr.to(self.device)
b, c, h, w = lr.size()
min_size = 360000
if ((h * w * scale * scale) > min_size):
sr = self.forward_chop(lr,
scale,
min_size=min_size)
else:
poseMap, interMapY, interMapX = pose_map(
lr.shape[2:4], output_size=hr.shape[2:4])
sr = self.model(lr, poseMap, interMapY, interMapX)
# poseMapL, poseMapH, interMapY, interMapX = pose_map(lr.shape[2:4], output_size=hr.shape[2:4])
# sr = self.model(lr, poseMapL, poseMapH, interMapY, interMapX)
sr = sr.data.cpu()
sr = utility.quantize(sr, self.args.rgb_range)
save_list = [sr]
self.ckp.log[-1, 0, idx_data,
idx_scale] += utility.calc_psnr(
sr,
hr,
scale,
self.args.rgb_range,
dataset=d)
self.ckp.log[-1, 1, idx_data,
idx_scale] += utility.calc_ssim(
sr,
hr,
scale,
self.args.rgb_range,
dataset=d)
if self.args.save_gt:
save_list.extend([lr, hr])
if self.args.save_results:
self.ckp.save_results(d, filename[0], save_list,
scale)
del sr
del hr
del lr
del save_list
# fname = self.ckp.get_path(
# 'results-{}'.format(d.dataset.name),
# '{}_x{}_FL_'.format(filename[0], scale)
# )
# self.saveFeature(fl.data.cpu().numpy()[0], fname)
# fname = self.ckp.get_path(
# 'results-{}'.format(d.dataset.name),
# '{}_x{}_FH_'.format(filename[0], scale)
# )
# self.saveFeature(fh.data.cpu().numpy()[0], fname)
self.ckp.log[-1, 0, idx_data, idx_scale] /= len(d)
self.ckp.log[-1, 1, idx_data, idx_scale] /= len(d)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}]\tPSNR: {:.3f} SSIM: {:.4f} (Best PSNR: {:.3f} @epoch {} Best SSIM: {:.4f} @epoch {})'
.format(d.dataset.name, scale, self.ckp.log[-1, 0,
idx_data,
idx_scale],
self.ckp.log[-1, 1, idx_data,
idx_scale], best[0][0, idx_data,
idx_scale],
best[1][0, idx_data, idx_scale] + 1,
best[0][1, idx_data, idx_scale],
best[1][1, idx_data, idx_scale] + 1))
torch.cuda.empty_cache()
self.ckp.write_log('Forward: {:.2f}s\n'.format(timer_test.toc()))
self.ckp.write_log('Saving...')
if self.args.save_results:
self.ckp.end_background()
if not self.args.test_only:
# self.ckp.save(self, epoch, is_best=(best[1][0, 0, 0] + 1 == epoch))
self.ckp.save(self,
epoch,
is_best=(torch.sum(best[1][0, :, :] +
1 == epoch)))
self.ckp.write_log('Total: {:.2f}s\n'.format(timer_test.toc()),
refresh=True)
def test(self):
self.model.eval()
with torch.no_grad():
for idx_scale, _ in enumerate(self.scale):
self.loader_test.dataset.set_scale(idx_scale)
scale = self.args.scale[idx_scale]
scale2 = self.args.scale2[idx_scale]
eval_psnr = 0
eval_ssim = 0
for idx_img, (lr, hr, filename,
_) in enumerate(self.loader_test):
filename = filename[0]
# prepare LR & HR images
no_eval = (hr.nelement() == 1)
if not no_eval:
lr, hr = self.prepare(lr, hr)
else:
lr, = self.prepare(lr)
lr, hr = self.crop_border(lr, hr, scale, scale2)
# inference
self.model.get_model().set_scale(scale, scale2)
sr = self.model(lr)
# evaluation
sr = utility.quantize(sr, self.args.rgb_range)
save_list = [sr]
if not no_eval:
eval_psnr += utility.calc_psnr(
sr,
hr, [scale, scale2],
self.args.rgb_range,
benchmark=self.loader_test.dataset.benchmark)
eval_ssim += utility.calc_ssim(
sr,
hr, [scale, scale2],
benchmark=self.loader_test.dataset.benchmark)
# save SR results
if self.args.save_results:
self.ckp.save_results(filename, save_list, scale)
if scale == scale2:
print('[{} x{}]\tPSNR: {:.3f} SSIM: {:.4f}'.format(
self.args.data_test,
scale,
eval_psnr / len(self.loader_test),
eval_ssim / len(self.loader_test),
))
else:
print('[{} x{}/x{}]\tPSNR: {:.3f} SSIM: {:.4f}'.format(
self.args.data_test,
scale,
scale2,
eval_psnr / len(self.loader_test),
eval_ssim / len(self.loader_test),
))
def test(self):
epoch = self.scheduler.last_epoch + 1
self.ckp.write_log('\nEvaluation:')
self.ckp.add_log(torch.zeros(1, len(self.scale)))
self.model.eval()
timer_test = utility.timer()
with torch.no_grad():
for idx_scale, scale in enumerate(self.scale):
self.loader_test.dataset.set_scale(idx_scale)
eval_acc = 0
eval_acc_ssim = 0
# Kernel split
# Note that, this part of code does not need to be executed at each run.
# After training, one can run this part of code once and save the splitted kernels.
for m in self.model.modules():
if hasattr(m, '_prepare'):
m._prepare()
for idx_img, (lr, hr, filename,
_) in enumerate(self.loader_test):
no_eval = (hr.nelement() == 1)
if not no_eval:
lr, hr = self.prepare(lr, hr)
else:
lr, = self.prepare(lr)
lr, hr = self.crop_border(lr, hr, scale)
sr = self.model(lr, idx_scale)
# run a second time to record inference time
for idx_img, (lr, hr, filename,
_) in enumerate(self.loader_test):
filename = filename[0]
no_eval = (hr.nelement() == 1)
if not no_eval:
lr, hr = self.prepare(lr, hr)
else:
lr, = self.prepare(lr)
lr, hr = self.crop_border(lr, hr, scale)
timer_test.tic()
sr = self.model(lr, idx_scale)
timer_test.hold()
sr = utility.quantize(sr, self.args.rgb_range)
hr = utility.quantize(hr, self.args.rgb_range)
save_list = [sr]
if not no_eval:
eval_acc += utility.calc_psnr(
sr,
hr,
scale,
self.args.rgb_range,
benchmark=self.loader_test.dataset.benchmark)
eval_acc_ssim += utility.calc_ssim(
sr,
hr,
scale,
benchmark=self.loader_test.dataset.benchmark)
if self.args.save_results:
self.ckp.save_results(filename, save_list, scale)
self.ckp.log[-1, idx_scale] = eval_acc / len(self.loader_test)
best = self.ckp.log.max(0)
self.ckp.write_log(
'[{} x{}] {:.4f}s\tPSNR: {:.3f} SSIM: {:.4f} (Best: {:.3f} @epoch {})'
.format(self.args.data_test, scale,
timer_test.release() / len(self.loader_test),
eval_acc / len(self.loader_test),
eval_acc_ssim / len(self.loader_test),
best[0][idx_scale], best[1][idx_scale] + 1))
# self.ckp.write_log(
# 'Total time: {:.2f}s\n'.format(timer_test.release()/len(self.loader_test)), refresh=True
# )
if not self.args.test_only:
self.ckp.save(self, epoch, is_best=(best[1][0] + 1 == epoch))
