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))