def test_VDSR_with_sess(epoch, ckpt_path, data_path, sess): folder_list = glob.glob(os.path.join(data_path, 'Set*')) print('folder_list', folder_list) saver.restore(sess, ckpt_path) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) for i in range(len(img_list)): input_list, gt_list, scale_list = get_test_image(img_list, i, 1) input_y = input_list[0] gt_y = gt_list[0] img_vdsr_y = sess.run( [output_tensor], feed_dict={ input_tensor: np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) }) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) print("PSNR: bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr)) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list with open('psnr/%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def test_VDSR_with_sess(epoch, data_path, sess): folder_list = glob.glob(os.path.join(data_path, 'Set*')) print('folder_list', folder_list) saver.restore(sess, tf.train.latest_checkpoint("./checkpoints/")) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) for i in range(len(img_list)): input_list, gt_list, scale_list = get_test_image(img_list, i, 1) input_y = input_list[0] gt_y = gt_list[0] start_t = time.time() img_vdsr_y = sess.run( [output_tensor], feed_dict={ input_tensor: np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) }) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) end_t = time.time() print("end_t", end_t, "start_t", start_t) print("time consumption", end_t - start_t) print("image_size", input_y.shape) psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) print("PSNR: bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr)) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list
def test_VDSR_with_sess(epoch, ckpt_path, data_path,sess): # folder_list = glob.glob(os.path.join(data_path, 'Set*')) # print('folder_list', folder_list) # ./data/test/Set5 folder_list = glob.glob(os.path.join(data_path, SUB_PATH)) print('folder_list', folder_list) saver.restore(sess, ckpt_path) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) print("file number in ", folder_path, ": ", len(img_list)) for i in range(len(img_list)): input_list, gt_list, scale_list = get_test_image(img_list, i, 1) input_y = input_list[0] gt_y = gt_list[0] start_t = time.time() input_array = np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) img_vdsr_y = sess.run([output_tensor], feed_dict={input_tensor: input_array}) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) end_t = time.time() print("end_t",end_t,"start_t",start_t) print("time consumption",end_t-start_t) print("image_size", input_y.shape) psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) print("PSNR: bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr)) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list with open('psnr/%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def Show_result(Denoiser, loader, pause, check=False): Denoiser.eval() plt.ion() plt.show() #Calcul de la PSNR moyenne PSNRmoy = 0 Compteur = 0 for i, data in enumerate(loader): images, groundtrue = data plt.figure(1) plt.clf() plt.imshow( np.clip( np.transpose( tu.make_grid(groundtrue, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') print("Image bruitée") plt.figure(2) plt.clf() plt.imshow( np.clip( np.transpose( tu.make_grid(images, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') A = psnr(groundtrue.numpy(), images.numpy(), check=check) plt.title(r'%f ' % A) print("Image débruitée") plt.figure(3) plt.clf() images = Denoiser( Variable(images, requires_grad=False).type(gpu_dtype)).data.cpu() plt.imshow( np.clip( np.transpose( tu.make_grid(images, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') A = psnr(groundtrue.numpy(), images.numpy(), check=check) PSNRmoy += A Compteur += 1 plt.title(r'%f ' % A) plt.pause(pause) print('PSNR moyen = %f ' % (PSNRmoy / Compteur))
def test_VDSR_with_sess( epoch, ckpt_path, data_path, sess, ): folder_list = glob.glob(os.path.join(data_path)) print 'folder_list', folder_list saver.restore(sess, ckpt_path) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) for i in range(len(img_list)): (input_list, gt_list, scale_list) = get_image_batch(img_list, i, 2) input_y = input_list gt_y = gt_list # print input_y[0].shape start_t = time.time() # img_vdsr_y = sess.run([output_tensor], # feed_dict={input_tensor: np.resize(input_y, # (1, input_y.shape[0], # input_y.shape[1], 1))}) img_vdsr_y = sess.run([output_tensor], feed_dict={input_tensor: input_y}) print np.asarray(img_vdsr_y).shape # img_vdsr_y = np.resize(img_vdsr_y, (2, input_y.shape[1], # input_y.shape[2],1)) end_t = time.time() print 'end_t', end_t, 'start_t', start_t print 'time consumption', end_t - start_t print 'image_size', input_y.shape img_vdsr_y = np.asarray(img_vdsr_y[0]) print 'img_vdsr_y', img_vdsr_y.shape print 'input_y', input_y.shape print 'gt_y', gt_y.shape # misc.toimage(np.resize(img_vdsr_y[0],(input_y.shape[1], input_y.shape[2]) ), # cmin=0.0,cmax=1.0).save('outfile_%d.jpg' % i) img = util.combine_img_prediction(input_y, gt_y, img_vdsr_y) util.save_image(img, 'outfile%d.jpg' % i) scipy.io.savemat('outfile%d' % i, mdict={'img': img_vdsr_y}) # misc.toimage(img_vdsr_y).save('outfile%d.jpg' %i) psnr_bicub = psnr(input_y, gt_y, scale_list) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list) print 'PSNR: bicubic %f\tVDSR %f' % (psnr_bicub, psnr_vdsr) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list]) psnr_dict[os.path.basename(folder_path)] = psnr_list with open('psnr/%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def test_VDSR_with_sess(epoch, ckpt_path, data_path, sess): folder_list = glob.glob(os.path.join(data_path, 'Set*')) print 'folder_list', folder_list saver.restore(sess, ckpt_path) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) #print('img_list: ',img_list) for i in range(len(img_list)): input_list, gt_list, scale_list = get_test_image(img_list, i, 1) input_y = input_list[0] gt_y = gt_list[0] start_t = time.time() img_vdsr_y = sess.run( [output_tensor], feed_dict={ input_tensor: np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) }) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) end_t = time.time() print "end_t", end_t, "start_t", start_t print "time consumption", end_t - start_t print "image_size", input_y.shape img_y = nparryToImage(img_vdsr_y) ''' img_cb = nparryToImage(gt_list[1]) img_cr = nparryToImage(gt_list[2]) img_cb = img_cb.resize(img_y.size,Image.BICUBIC) img_cr = img_cr.resize(img_y.size,Image.BICUBIC) img_rgb = YcrcbToRGB(img_y,img_cb,img_cr) img_rgb.show() ''' img_y.show() psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) print "PSNR: bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list with open('psnr/%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def test_VDSR_with_sess(self, ckpt_path, data_path, output_tensor, saver): folder_list = glob.glob(os.path.join(data_path, 'Set*')) print('folder_list', folder_list) saver.restore(self.sess, ckpt_path) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = self.get_img_list(folder_path) print('img_list', img_list) for i in range(len(img_list)): input_list, gt_list, scale_list = self.get_test_image( img_list, i, 1) print(len(input_list)) input_y = input_list[0] gt_y = gt_list[0] start_t = time.time() img_vdsr_y = self.sess.run( [output_tensor], feed_dict={ self.input_tensor: np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) }) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) end_t = time.time() print("end_t", end_t, "start_t", start_t) print("time consumption", end_t - start_t) print("image_Size", input_y.shape) psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) print("bicubic PSNR: %f \t VDSR PSNR: %f" % (psnr_bicub, psnr_vdsr)) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list print("psnr_dict:", psnr_dict) with open('./psnr\%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def test_VDSR_with_sess(epoch, ckpt_path, data_path, sess): folder_list = glob.glob(os.path.join(data_path, 'Set*')) print 'folder_list', folder_list input_tensor = tf.placeholder(tf.float32, shape=(1, None, None, 1)) output_tensor, weights = model(input_tensor) #output_tensor, weights = model_factorized(input_tensor) tf.get_variable_scope().reuse_variables() saver = tf.train.Saver(weights) tf.initialize_all_variables().run() saver.restore(sess, ckpt_path) psnr_dict = {} for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) for i in range(len(img_list)): input_list, gt_list, scale_list = get_test_image(img_list, i, 1) input_y = input_list[0] gt_y = gt_list[0] img_vdsr_y = sess.run( [output_tensor], feed_dict={ input_tensor: np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) }) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) print "PSNR: bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list with open('psnr/%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def test_with_sess(epoch, ckpt_path, data_path,sess): psnr_list = [] for i in range(2): psnr_list.append([]) for i in range(3): psnr_list[0].append([]) psnr_list[1].append([]) saver.restore(sess, ckpt_path) for i, item in enumerate(file_list): file_name = os.path.splitext(item) img_raw = imread(path_dir+item) width = img_raw.shape[1] height = img_raw.shape[0] if len(img_raw.shape) == 3: im_gt_ycbcr = np.round(rgb2ycbcr(img_raw)).astype('uint8') im_gt_ycbcr = cropping(im_gt_ycbcr,height,width) img_raw = im_gt_ycbcr[:,:,0]/255.0 is_gray = False elif len(img_raw.shape) == 2: im_gt_ycbcr = 0 img_raw = img_raw/255.0 is_gray = True img_raw = cropping(img_raw, height, width).astype(np.float32) for x in range(2,5):#About scale X2, X3, X4 im_gt_y = imresize(imresize(img_raw, 1/x, interp='bicubic', mode='F'), [img_raw.shape[0], img_raw.shape[1]], interp='bicubic', mode='F') result_y = sess.run([output_tensor], feed_dict={input_tensor: np.resize(im_gt_y, (1, im_gt_y.shape[0], im_gt_y.shape[1], 1)), keep_prob: 1.0}) result_y = np.resize(result_y, (im_gt_y.shape[0], im_gt_y.shape[1])) result_y = result_y.clip(16/255, 235/255) image = colorize(result_y, im_gt_ycbcr, is_gray) image.save(result_path_dir+file_name[0]+"X"+str(x)+file_name[1]) psnr_list[0][x - 2].append(psnr(result_y, img_raw, x)) psnr_list[1][x - 2].append(psnr(im_gt_y, img_raw, x)) print("OURS\nX2 : %f db \nX3 : %f db \nX4 : %f db \n" % (np.mean(psnr_list[0][0]), np.mean(psnr_list[0][1]), np.mean(psnr_list[0][2]))) print("BICUBIC\nX2 : %f db \nX3 : %f db \nX4 : %f db \n" % (np.mean(psnr_list[1][0]), np.mean(psnr_list[1][1]), np.mean(psnr_list[1][2])))
learning_rate, global_step, ], feed_dict=feed_dict) # del input_data, gt_data, cbcr_data print output.shape img = util.combine_img_prediction(input_data, gt_data, output + input_data) name = 'epoch_%s' % epoch util.save_image(img, '%s/%s.jpg' % (prediction_path, name)) print '[epoch %2.4f] loss %.4f\t acc %.4f\t lr %.7f' \ % (epoch + float(step) * BATCH_SIZE / len(train_list), np.sum(l), accuracy, lr) psnr_bicub = psnr(input_data, gt_data, 0) psnr_vdsr = psnr(output + input_data, gt_data, 0) print 'PSNR: bicubic %f\U-NET %f' % (psnr_bicub, psnr_vdsr) # print "[epoch %2.4f] loss %.4f\t lr %.7f"%(epoch+(float(step)*BATCH_SIZE/len(train_list)), np.sum(l)/BATCH_SIZE, lr) # saver.save(sess, "./checkpoints/VDSR_const_clip_0.01_epoch_%03d.ckpt" % epoch ,global_step=global_step) saver.save(sess, ckpt_path) # test_VDSR(epoch, ckpt_path, TEST_DATA_PATH) img_list = get_train_list(TEST_DATA_PATH) # print img_list
def Show_burst2(Denoiser, SFD, loader, pause, framerate=0.1, check=False): Denoiser.eval() SFD.eval() with torch.no_grad(): plt.ion() plt.show() #Calcul de la PSNR moyenne PSNRmoyLast = 0 PSNRmoyFirst = 0 PSNRmoyMSFDLast = 0 PSNRmoyMSFDFirst = 0 PSNRmoySFDLast = 0 PSNRmoySFDFirst = 0 Compteur = 0 for t, (x, y) in enumerate(loader): x_var = Variable(torch.transpose(x.type(gpu_dtype), 0, 1), requires_grad=False) y = torch.transpose(y, 0, 1) i = 0 for frame, target in zip(x_var, y): if i == 0: images = target[0] plt.figure(1) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') c, h, w = images.shape images = frame.data[0].cpu() print("Image bruitée 1") plt.figure(2) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') A = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % A) mfinit1, mfinit2, mfinit3, mfinit4, mfinit5, mfinit6, mfinit7 = torch.zeros( 7, loader.batch_size, 64, h, w, requires_grad=False).cuda() mfinit8 = torch.zeros(loader.batch_size, c, h, w, requires_grad=False).cuda() i += 1 frame1, mf1, mf2, mf3, mf4, mf5, mf6, mf7, mf8 = Denoiser( frame, mfinit1, mfinit2, mfinit3, mfinit4, mfinit5, mfinit6, mfinit7, mfinit8) frame = SFD(frame) images = frame1.data[0].cpu() print("Image 1 debruité MSFD") plt.figure(3) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') A = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % A) PSNRmoyMSFDFirst += A images = frame.data[0].cpu() print("Image 1 debruité MSFD") plt.figure(4) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') A = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % A) PSNRmoySFDFirst += A images = mf8.data[0].cpu() print("Image 1 debruité MFD") plt.figure(5) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') A = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % A) PSNRmoyFirst += A torch.cuda.empty_cache() else: i += 1 images = target[0] plt.figure(6) plt.clf() images = np.clip(images, 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') images = frame.data[0].cpu() print("Image %d bruitée" % i) plt.figure(7) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') A = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % A) frame1, mf1, mf2, mf3, mf4, mf5, mf6, mf7, mf8 = Denoiser( frame, mf1, mf2, mf3, mf4, mf5, mf6, mf7, mf8) frame = SFD(frame) images = frame1.data[0].cpu() print("Image %d debruitée MSFD" % i) plt.figure(8) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') B = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % B) images = frame.data[0].cpu() print("Image %d debruité SFD" % i) plt.figure(9) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') D = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % D) images = mf8.data[0].cpu() print("Image %d debruitée MFD " % i) plt.figure(10) plt.clf() images = np.clip(images.numpy(), 0, 1) plt.imshow(np.transpose(images, (1, 2, 0))) plt.axis('off') A = psnr(target[0].numpy(), images, check=check) plt.title(r'%f ' % A) torch.cuda.empty_cache() plt.pause(framerate) PSNRmoyMSFDLast += B PSNRmoyLast += A PSNRmoySFDLast += D Compteur += 1 plt.pause(pause) print(' Mean PSNR MFD First = %f ' % (PSNRmoyFirst / Compteur)) print(' Mean PSNR MFD Last = %f ' % (PSNRmoyLast / Compteur)) print(' Mean PSNR MSFD Last = %f ' % (PSNRmoyMSFDLast / Compteur)) print(' Mean PSNR SFD First = %f ' % (PSNRmoyMSFDFirst / Compteur)) print(' Mean PSNR SFD Last = %f ' % (PSNRmoySFDLast / Compteur)) print(' Mean PSNR SFD First = %f ' % (PSNRmoySFDFirst / Compteur))
def Show_result2(Denoiser1, Denoiser2, loader, pause, check=False): Denoiser1.eval() Denoiser2.eval() plt.ion() plt.show() #Calcul de la PSNR moyenne PSNRmoy1 = 0 PSNRmoy2 = 0 Compteur = 0 for i, data in enumerate(loader): images, groundtrue = data plt.figure(1) plt.clf() plt.imshow( np.clip( np.transpose( tu.make_grid(groundtrue, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') print("Image bruitée") plt.figure(2) plt.clf() plt.imshow( np.clip( np.transpose( tu.make_grid(images, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') A = psnr(groundtrue.numpy(), images.numpy(), check=check) plt.title(r'%f ' % A) print("Image débruitée par 1") plt.figure(3) plt.clf() images1 = Denoiser1( Variable(images, requires_grad=False).type(gpu_dtype)).data.cpu() plt.imshow( np.clip( np.transpose( tu.make_grid(images1, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') A = psnr(groundtrue.numpy(), images1.numpy(), check=check) PSNRmoy1 += A Compteur += 1 plt.title(r' Denoiseur1 PSNR=%f ' % A) print("Image débruitée par 2") plt.figure(4) plt.clf() images2 = Denoiser2( Variable(images, requires_grad=False).type(gpu_dtype)).data.cpu() plt.imshow( np.clip( np.transpose( tu.make_grid(images2, range=(0, 1), nrow=4).numpy(), (1, 2, 0)), 0, 1)) plt.axis('off') A = psnr(groundtrue.numpy(), images2.numpy()) PSNRmoy2 += A plt.title(r' Denoiseur2 PSNR= %f ' % A) plt.pause(pause) print(' Mean PSNR denoiseur1 = %f ' % (PSNRmoy1 / Compteur)) print(' Mean PSNR denoiseur2 = %f ' % (PSNRmoy2 / Compteur))
def test_VDSR_with_sess(epoch, ckpt_path, data_path, sess): folder_list = glob.glob(os.path.join(data_path, 'Set*')) #'Set*' print('folder_list', folder_list) #folder_list [./data/test//Set14] if not os.path.exists('./output_img'): os.mkdir('./output_img') saver.restore(sess, ckpt_path) psnr_dict = {} psnr_bicub_cnt_2 = 0 psnr_bicub_sum_2 = 0 psnr_bicub_total_2 = 0 psnr_bicub_cnt_3 = 0 psnr_bicub_sum_3 = 0 psnr_bicub_total_3 = 0 # psnr_bicub_cnt_4 = 0 psnr_bicub_sum_4 = 0 psnr_bicub_total_4 = 0 psnr_vdsr_cnt_2 = 0 psnr_vdsr_sum_2 = 0 psnr_vdsr_total_2 = 0 psnr_vdsr_cnt_3 = 0 psnr_vdsr_sum_3 = 0 psnr_vdsr_total_3 = 0 psnr_vdsr_cnt_4 = 0 psnr_vdsr_sum_4 = 0 psnr_vdsr_total_4 = 0 input_cnt = 0 vdsr_cnt = 0 gt_cnt = 0 for folder_path in folder_list: psnr_list = [] img_list = get_img_list(folder_path) for i in range(len(img_list)): input_list, gt_list, scale_list = get_test_image(img_list, i, 1) input_y = input_list[0] gt_y = gt_list[0] start_t = time.time() img_vdsr_y = sess.run( [output_tensor], feed_dict={ input_tensor: np.resize(input_y, (1, input_y.shape[0], input_y.shape[1], 1)) }) img_vdsr_y = np.resize(img_vdsr_y, (input_y.shape[0], input_y.shape[1])) end_t = time.time() print("end_t", end_t, "start_t", start_t) print("time consumption", end_t - start_t) print("image_size", input_y.shape) input_count = str(input_cnt) vdsr_count = str(vdsr_cnt) gt_count = str(gt_cnt) #save test image and results id = img_list[i][1].split('/')[-1].split('.')[0] # output_id = 'output'+id+'.png' # input_id = 'input' + id + '.png' filename = os.path.basename( model_ckpt.split('/')[-1].split('.')[0]) #print('filename=', filename) #scipy.misc.imsave(os.path.join('./output_img', 'image.png'),img_vdsr_y) #scipy.misc.imsave('image.png',img_vdsr_y) # scipy.misc.imsave(os.path.join('./output_img', filename+'_input'+input_count+'.png'),input_y) #image 생성 # scipy.misc.imsave(os.path.join('./output_img', 'gt'+'_'+gt_count+'.png'),gt_y) #image 생성 # scipy.misc.imsave(os.path.join('./output_img',input_id),input_y) # scipy.misc.imsave(os.path.join('/output_img',output_id),img_vdsr_y) if scale_list[0] == 2: psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_bicub_cnt_2 += 1 psnr_bicub_sum_2 += psnr_bicub psnr_bicub_total_2 = psnr_bicub_sum_2 / psnr_bicub_cnt_2 psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) psnr_vdsr_cnt_2 += 1 psnr_vdsr_sum_2 += psnr_vdsr psnr_vdsr_total_2 = psnr_vdsr_sum_2 / psnr_vdsr_cnt_2 scipy.misc.imsave( os.path.join( './output_img', filename + '_ground_truth' + '_x2' + gt_count + '.png'), gt_y) scipy.misc.imsave( os.path.join( './output_img', filename + '_outputx2' + '_' + vdsr_count + '.png'), img_vdsr_y) scipy.misc.imsave( os.path.join( './output_img', filename + '_bicubicx2' + '_' + input_count + '.png'), input_y) # print("%d 번째 Average PSNR x2 scale: bicubic %f\tVDSR %f" %(psnr_bicub_cnt_2,psnr_bicub_total_2, psnr_vdsr_total_2)) print("PSNR x2 scale : bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr)) if scale_list[0] == 3: psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_bicub_cnt_3 += 1 psnr_bicub_sum_3 += psnr_bicub psnr_bicub_total_3 = psnr_bicub_sum_3 / psnr_bicub_cnt_3 psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) psnr_vdsr_cnt_3 += 1 psnr_vdsr_sum_3 += psnr_vdsr psnr_vdsr_total_3 = psnr_vdsr_sum_3 / psnr_vdsr_cnt_3 scipy.misc.imsave( os.path.join('./output_img', 'ground_truth' + '_x3' + gt_count + '.png'), gt_y) scipy.misc.imsave( os.path.join( './output_img', filename + '_outputx3' + '_' + vdsr_count + '.png'), img_vdsr_y) scipy.misc.imsave( os.path.join( './output_img', filename + '_bicubicx3' + '_' + input_count + '.png'), input_y) # print("%d 번째 Average PSNR x3 scale: bicubic %f\tVDSR %f" %(psnr_bicub_cnt_3,psnr_bicub_total_3, psnr_vdsr_total_3)) print("PSNR x3 scale : bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr)) if scale_list[0] == 4: psnr_bicub = psnr(input_y, gt_y, scale_list[0]) psnr_bicub_cnt_4 += 1 psnr_bicub_sum_4 += psnr_bicub psnr_bicub_total_4 = psnr_bicub_sum_4 / psnr_bicub_cnt_4 psnr_vdsr = psnr(img_vdsr_y, gt_y, scale_list[0]) psnr_vdsr_cnt_4 += 1 psnr_vdsr_sum_4 += psnr_vdsr psnr_vdsr_total_4 = psnr_vdsr_sum_4 / psnr_vdsr_cnt_4 scipy.misc.imsave( os.path.join('./output_img', 'ground_truth' + '_x4' + gt_count + '.png'), gt_y) scipy.misc.imsave( os.path.join( './output_img', filename + '_outputx4' + '_' + vdsr_count + '.png'), img_vdsr_y) scipy.misc.imsave( os.path.join( './output_img', filename + '_bicubicx4' + '_' + input_count + '.png'), input_y) # print("%d 번째 Average PSNR x4 scale: bicubic %f\tVDSR %f" %(psnr_bicub_cnt_4, psnr_bicub_total_4, psnr_vdsr_total_4)) print("PSNR x4 scale : bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr)) input_cnt += 1 vdsr_cnt += 1 gt_cnt += 1 # print ("PSNR: bicubic %f\tVDSR %f" % (psnr_bicub, psnr_vdsr) psnr_list.append([psnr_bicub, psnr_vdsr, scale_list[0]]) psnr_dict[os.path.basename(folder_path)] = psnr_list if not os.path.exists('./psnr'): os.mkdir('psnr') with open('psnr/%s' % os.path.basename(ckpt_path), 'wb') as f: pickle.dump(psnr_dict, f)
def evaluate(): ## create folders to save result images save_dir = "samples/{}".format(tl.global_flag['mode']) tl.files.exists_or_mkdir(save_dir) checkpoint_dir = "checkpoint" ###====================== PRE-LOAD DATA ===========================### valid_hr_img_list = glob.glob(os.path.join(config.VALID.hr_img_path, "*")) valid_hr_img_list = [ f for f in valid_hr_img_list if os.path.splitext(f)[-1] == '.png' ] #valid_hr_imgs = tl.vis.read_images(valid_hr_img_list, path=config.VALID.hr_img_path, n_threads=32) valid_hr_imgs = [] for f in valid_hr_img_list: #print(f) img = cv2.imread(f, cv2.IMREAD_UNCHANGED) #print(img[1:10,1:10,0]) max_value = np.max(img) print('max_value:{}'.format(max_value)) valid_hr_imgs.append(img) ###========================== DEFINE MODEL ============================### G = get_G([1, None, None, 3]) #G.load_weights(checkpoint_dir + '/g_{}.h5'.format(tl.global_flag['mode'])) G.load_weights(checkpoint_dir + '/g_{}.h5'.format('srgan')) G.eval() for imid in range(8): #imid =7 valid_hr_img = valid_hr_imgs[imid] valid_hr_img = cv2.resize(valid_hr_img, (500, 218), interpolation=cv2.INTER_CUBIC) valid_lr_img = tf.floor(valid_hr_img / 4096.0) valid_lr_img = valid_lr_img * 4096.0 valid_lr_img = (valid_lr_img / 32767.5) - 1 # rescale to [-1, 1] valid_lr_img = tf.cast(valid_lr_img, dtype=tf.float32) valid_lr_img_input = tf.reshape(valid_lr_img, [ 1, valid_lr_img.shape[0], valid_lr_img.shape[1], valid_lr_img.shape[2] ]) # print(valid_lr_img.min(), valid_lr_img.max()) # print(valid_lr_img.shape) # G = get_G([1, None, None, 3]) # #G.load_weights(checkpoint_dir + '/g_{}.h5'.format(tl.global_flag['mode'])) # G.load_weights(checkpoint_dir + '/g_{}.h5'.format('srgan')) # G.eval() out = G(valid_lr_img_input).numpy() print(np.min(out), np.max(out)) # cv2.imshow('out',out[0]) # cv2.waitKey(0) # print("[*] save images") # tl.vis.save_image(out[0], save_dir + '/valid_gen_{}.png'.format(str(imid))) # tl.vis.save_image(valid_lr_img, save_dir + '/valid_lr_{}.png'.format(str(imid))) # tl.vis.save_image(valid_hr_img, save_dir + '/valid_hr_{}.png'.format(str(imid))) '''do not use tl.vis.save_image,for which do not support 16bit mode''' out = tf.cast((out[0] + 1) * 32767.5, dtype=tf.uint16).numpy() #out=out.eval() valid_lr_img = tf.cast((valid_lr_img + 1) * 32767.5, dtype=tf.uint16).numpy() valid_hr_img = tf.cast(valid_hr_img, dtype=tf.uint16).numpy() # cv2.imshow('out',out) # cv2.waitKey(0) # print(np.max(out)) # print(np.min(out)) psnr_gen = psnr(np.float32(out), np.float32(valid_hr_img), 2) psnr_zp = psnr(np.float32(valid_lr_img), np.float32(valid_hr_img), 2) print('psnr_gen:{} psnr_zp:{}'.format(psnr_gen, psnr_zp)) cv2.imwrite(save_dir + '/valid_gen_{}.png'.format(str(imid)), out, [int(cv2.IMWRITE_PNG_COMPRESSION), 0]) cv2.imwrite(save_dir + '/valid_lr_{}.png'.format(str(imid)), valid_lr_img, [int(cv2.IMWRITE_PNG_COMPRESSION), 0]) cv2.imwrite(save_dir + '/valid_hr_{}.png'.format(str(imid)), valid_hr_img, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
avg_psnr_predicted = 0.0 avg_psnr_bicubic = 0.0 avg_elapsed_time = 0.0 count = 0.0 for image_name in image_list: # print("image name: ", image_name) if str(scale) in image_name: print("Processing ", image_name) # keys: 'im_gt_y', 'im_b_y', 'im_gt', 'im_b', 'im_l_ycbcr', 'im_l_y', 'im_l' im_gt_y = sio.loadmat(image_name)['im_gt_y'] im_b_y = sio.loadmat(image_name)['im_b_y'] im_gt_y = im_gt_y.astype(float) / 255. im_b_y = im_b_y.astype(float) / 255. psnr_bicubic = psnr(im_gt_y, im_b_y, scale) avg_psnr_bicubic += psnr_bicubic input_array = np.resize( im_b_y, (1, im_b_y.shape[0], im_b_y.shape[1], 1)) start_t = time.time() img_vdsr = sess.run(train_output, feed_dict={train_input: input_array}) end_t = time.time() img_vdsr = np.resize(img_vdsr, (im_b_y.shape[0], im_b_y.shape[1])) elapsed_time = end_t - start_t avg_elapsed_time += elapsed_time psnr_predicted = psnr(im_gt_y, img_vdsr, scale)