def test_wavelet_denoising_nd(): rstate = np.random.RandomState(1234) for method in ['VisuShrink', 'BayesShrink']: for ndim in range(1, 5): # Generate a very simple test image if ndim < 3: img = 0.2*np.ones((128, )*ndim) else: img = 0.2*np.ones((16, )*ndim) img[(slice(5, 13), ) * ndim] = 0.8 sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # Mark H. 2018.08: # The issue arises because when ndim in [1, 2] # ``waverecn`` calls ``_match_coeff_dims`` # Which includes a numpy 1.15 deprecation. # for larger number of dimensions _match_coeff_dims isn't called # for some reason. anticipated_warnings = (PYWAVELET_ND_INDEXING_WARNING if ndim < 3 else None) with expected_warnings([anticipated_warnings]): # Verify that SNR is improved with internally estimated sigma denoised = restoration.denoise_wavelet(noisy, method=method) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy)
def test_wavelet_denoising(): for img, multichannel in [(astro_gray, False), (astro, True)]: sigma = 0.1 noisy = img + sigma * np.random.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # Verify that SNR is improved when true sigma is used denoised = restoration.denoise_wavelet(noisy, sigma=sigma, multichannel=multichannel) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert psnr_denoised > psnr_noisy # Verify that SNR is improved with internally estimated sigma denoised = restoration.denoise_wavelet(noisy, multichannel=multichannel) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert psnr_denoised > psnr_noisy # Test changing noise_std (higher threshold, so less energy in signal) res1 = restoration.denoise_wavelet(noisy, sigma=2*sigma, multichannel=multichannel) res2 = restoration.denoise_wavelet(noisy, sigma=sigma, multichannel=multichannel) assert (res1.sum()**2 <= res2.sum()**2)
def test_wavelet_denoising_levels(): rstate = np.random.RandomState(1234) ndim = 2 N = 256 wavelet = 'db1' # Generate a very simple test image img = 0.2*np.ones((N, )*ndim) img[[slice(5, 13), ] * ndim] = 0.8 sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) denoised = restoration.denoise_wavelet(noisy, wavelet=wavelet) denoised_1 = restoration.denoise_wavelet(noisy, wavelet=wavelet, wavelet_levels=1) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) psnr_denoised_1 = compare_psnr(img, denoised_1) # multi-level case should outperform single level case assert_(psnr_denoised > psnr_denoised_1 > psnr_noisy) # invalid number of wavelet levels results in a ValueError max_level = pywt.dwt_max_level(np.min(img.shape), pywt.Wavelet(wavelet).dec_len) assert_raises(ValueError, restoration.denoise_wavelet, noisy, wavelet=wavelet, wavelet_levels=max_level+1) assert_raises(ValueError, restoration.denoise_wavelet, noisy, wavelet=wavelet, wavelet_levels=-1)
def test_wavelet_threshold(): rstate = np.random.RandomState(1234) img = astro_gray sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # employ a single, user-specified threshold instead of BayesShrink sigmas with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): denoised = _wavelet_threshold(noisy, wavelet='db1', method=None, threshold=sigma) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy) # either method or threshold must be defined with testing.raises(ValueError): _wavelet_threshold(noisy, wavelet='db1', method=None, threshold=None) # warns if a threshold is provided in a case where it would be ignored with expected_warnings(["Thresholding method ", PYWAVELET_ND_INDEXING_WARNING]): _wavelet_threshold(noisy, wavelet='db1', method='BayesShrink', threshold=sigma)
def test_PSNR_dynamic_range_and_data_range(): # Tests deprecation of "dynamic_range" in favor of "data_range" out1 = compare_psnr(cam/255., cam_noisy/255., data_range=1) with expected_warnings( '`dynamic_range` has been deprecated in favor of ' '`data_range`. The `dynamic_range` keyword argument ' 'will be removed in v0.14'): out2 = compare_psnr(cam/255., cam_noisy/255., dynamic_range=1) assert_equal(out1, out2)
def test_wavelet_threshold(): rstate = np.random.RandomState(1234) img = astro_gray sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # employ a single, uniform threshold instead of BayesShrink sigmas denoised = _wavelet_threshold(noisy, wavelet='db1', threshold=sigma) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy)
def test_denoise_nl_means_multichannel(): # for true 3D data, 3D denoising is better than denoising as 2D+channels img = np.zeros((13, 10, 8)) img[6, 4:6, 2:-2] = 1. sigma = 0.3 imgn = img + sigma * np.random.randn(*img.shape) denoised_wrong_multichannel = restoration.denoise_nl_means( imgn, 3, 4, 0.6 * sigma, fast_mode=True, multichannel=True) denoised_ok_multichannel = restoration.denoise_nl_means( imgn, 3, 4, 0.6 * sigma, fast_mode=True, multichannel=False) psnr_wrong = compare_psnr(img, denoised_wrong_multichannel) psnr_ok = compare_psnr(img, denoised_ok_multichannel) assert_(psnr_ok > psnr_wrong)
def test_wavelet_denoising(): rstate = np.random.RandomState(1234) # version with one odd-sized dimension astro_gray_odd = astro_gray[:, :-1] astro_odd = astro[:, :-1] for img, multichannel, convert2ycbcr in [(astro_gray, False, False), (astro_gray_odd, False, False), (astro_odd, True, False), (astro_odd, True, True)]: sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # Verify that SNR is improved when true sigma is used with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): denoised = restoration.denoise_wavelet(noisy, sigma=sigma, multichannel=multichannel, convert2ycbcr=convert2ycbcr) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy) # Verify that SNR is improved with internally estimated sigma with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): denoised = restoration.denoise_wavelet(noisy, multichannel=multichannel, convert2ycbcr=convert2ycbcr) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy) # SNR is improved less with 1 wavelet level than with the default. denoised_1 = restoration.denoise_wavelet(noisy, multichannel=multichannel, wavelet_levels=1, convert2ycbcr=convert2ycbcr) psnr_denoised_1 = compare_psnr(img, denoised_1) assert_(psnr_denoised > psnr_denoised_1) assert_(psnr_denoised_1 > psnr_noisy) # Test changing noise_std (higher threshold, so less energy in signal) with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): res1 = restoration.denoise_wavelet(noisy, sigma=2 * sigma, multichannel=multichannel) with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): res2 = restoration.denoise_wavelet(noisy, sigma=sigma, multichannel=multichannel) assert_(np.sum(res1**2) <= np.sum(res2**2))
def test_wavelet_denoising_nd(): for ndim in range(1, 5): # Generate a very simple test image img = 0.2*np.ones((16, )*ndim) img[[slice(5, 13), ] * ndim] = 0.8 sigma = 0.1 noisy = img + sigma * np.random.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # Verify that SNR is improved with internally estimated sigma denoised = restoration.denoise_wavelet(noisy) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert psnr_denoised > psnr_noisy
def test_PSNR_float(): p_uint8 = compare_psnr(cam, cam_noisy) p_float64 = compare_psnr(cam / 255., cam_noisy / 255., data_range=1) assert_almost_equal(p_uint8, p_float64, decimal=5) # mixed precision inputs p_mixed = compare_psnr(cam / 255., np.float32(cam_noisy / 255.), data_range=1) assert_almost_equal(p_mixed, p_float64, decimal=5) # mismatched dtype results in a warning if data_range is unspecified with expected_warnings(['Inputs have mismatched dtype']): p_mixed = compare_psnr(cam / 255., np.float32(cam_noisy / 255.)) assert_almost_equal(p_mixed, p_float64, decimal=5)
def test_denoise_nl_means_3d(): img = np.zeros((12, 12, 8)) img[5:-5, 5:-5, 2:-2] = 1. sigma = 0.3 imgn = img + sigma * np.random.randn(*img.shape) psnr_noisy = compare_psnr(img, imgn) for s in [sigma, 0]: denoised = restoration.denoise_nl_means(imgn, 3, 4, h=0.75 * sigma, fast_mode=True, multichannel=False, sigma=s) # make sure noise is reduced assert_(compare_psnr(img, denoised) > psnr_noisy) denoised = restoration.denoise_nl_means(imgn, 3, 4, h=0.75 * sigma, fast_mode=False, multichannel=False, sigma=s) # make sure noise is reduced assert_(compare_psnr(img, denoised) > psnr_noisy)
def test_wavelet_denoising_levels(): rstate = np.random.RandomState(1234) ndim = 2 N = 256 wavelet = 'db1' # Generate a very simple test image img = 0.2*np.ones((N, )*ndim) img[(slice(5, 13), ) * ndim] = 0.8 sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): denoised = restoration.denoise_wavelet(noisy, wavelet=wavelet) denoised_1 = restoration.denoise_wavelet(noisy, wavelet=wavelet, wavelet_levels=1) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) psnr_denoised_1 = compare_psnr(img, denoised_1) # multi-level case should outperform single level case assert_(psnr_denoised > psnr_denoised_1 > psnr_noisy) # invalid number of wavelet levels results in a ValueError or UserWarning max_level = pywt.dwt_max_level(np.min(img.shape), pywt.Wavelet(wavelet).dec_len) if Version(pywt.__version__) < '1.0.0': # exceeding max_level raises a ValueError in PyWavelets 0.4-0.5.2 with testing.raises(ValueError): with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): restoration.denoise_wavelet( noisy, wavelet=wavelet, wavelet_levels=max_level + 1) else: # exceeding max_level raises a UserWarning in PyWavelets >= 1.0.0 with expected_warnings([ 'all coefficients will experience boundary effects']): restoration.denoise_wavelet( noisy, wavelet=wavelet, wavelet_levels=max_level + 1) with testing.raises(ValueError): with expected_warnings([PYWAVELET_ND_INDEXING_WARNING]): restoration.denoise_wavelet( noisy, wavelet=wavelet, wavelet_levels=-1)
def test(model): print('Start to test on {}'.format(args.test_dir)) out_dir = save_dir + args.test_dir.split('/')[-1] + '/' if not os.path.exists(out_dir): os.mkdir(out_dir) name = [] psnr = [] ssim = [] file_list = glob.glob('{}/*.png'.format(args.test_dir)) for file in file_list: # read image img_clean = np.array(Image.open(file), dtype='float32') / 255.0 img_test = img_clean + np.random.normal(0, args.sigma/255.0, img_clean.shape) img_test = img_test.astype('float32') # predict x_test = img_test.reshape(1, img_test.shape[0], img_test.shape[1], 1) y_predict = model.predict(x_test) # calculate numeric metrics img_out = y_predict.reshape(img_clean.shape) img_out = np.clip(img_out, 0, 1) psnr_noise, psnr_denoised = compare_psnr(img_clean, img_test), compare_psnr(img_clean, img_out) ssim_noise, ssim_denoised = compare_ssim(img_clean, img_test), compare_ssim(img_clean, img_out) psnr.append(psnr_denoised) ssim.append(ssim_denoised) # save images filename = file.split('/')[-1].split('.')[0] # get the name of image file name.append(filename) img_test = Image.fromarray((img_test*255).astype('uint8')) img_test.save(out_dir+filename+'_sigma'+'{}_psnr{:.2f}.png'.format(args.sigma, psnr_noise)) img_out = Image.fromarray((img_out*255).astype('uint8')) img_out.save(out_dir+filename+'_psnr{:.2f}.png'.format(psnr_denoised)) psnr_avg = sum(psnr)/len(psnr) ssim_avg = sum(ssim)/len(ssim) name.append('Average') psnr.append(psnr_avg) ssim.append(ssim_avg) print('Average PSNR = {0:.2f}, SSIM = {1:.2f}'.format(psnr_avg, ssim_avg)) pd.DataFrame({'name':np.array(name), 'psnr':np.array(psnr), 'ssim':np.array(ssim)}).to_csv(out_dir+'/metrics.csv', index=True)
def test_wavelet_denoising_nd(): rstate = np.random.RandomState(1234) for method in ['VisuShrink', 'BayesShrink']: for ndim in range(1, 5): # Generate a very simple test image if ndim < 3: img = 0.2*np.ones((128, )*ndim) else: img = 0.2*np.ones((16, )*ndim) img[[slice(5, 13), ] * ndim] = 0.8 sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # Verify that SNR is improved with internally estimated sigma denoised = restoration.denoise_wavelet(noisy, method=method) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy)
def test_denoise_nl_means_2d_multichannel(): # reduce image size because nl means is slow img = np.copy(astro[:50, :50]) img = np.concatenate((img, ) * 2, ) # 6 channels # add some random noise sigma = 0.1 imgn = img + sigma * np.random.standard_normal(img.shape) imgn = np.clip(imgn, 0, 1) for fast_mode in [True, False]: for s in [sigma, 0]: for n_channels in [2, 3, 6]: psnr_noisy = compare_psnr(img[..., :n_channels], imgn[..., :n_channels]) denoised = restoration.denoise_nl_means(imgn[..., :n_channels], 3, 5, h=0.75 * sigma, fast_mode=fast_mode, multichannel=True, sigma=s) psnr_denoised = compare_psnr(denoised[..., :n_channels], img[..., :n_channels]) # make sure noise is reduced assert_(psnr_denoised > psnr_noisy)
def get_denoise_metrics(input, output, report): image_file_name1 = input image_file_name2 = output image_name1 = io.imread(image_file_name1) image_name2 = io.imread(image_file_name2) # estimate the standard deiviation of the images std_1 = numpy.std(numpy.std(numpy.array(image_name1))) std_2 = numpy.std(numpy.std(numpy.array(image_name2))) print("std is %2.10f" % std_1) # print ("Standard deviation of the images are"%(std_1,std_2)) # estimate the peak signal to noise ratio (PSNR) between the image peak_signal_to_noise_ratio = measure.compare_psnr(image_name1, image_name2) print("Peak signal to noise ratio is %s" % peak_signal_to_noise_ratio) # estimate the mean square error between the images mse = measure.compare_mse(image_name1, image_name2) print("Mean square error between the images is %s" % mse) # estimate the normalised root mean square error between the images rmse = measure.compare_nrmse(image_name1, image_name2) print("Normalised root mean square error between the images is %s" % rmse) resp = open(report, 'w') resp.write("std1 is %2.10f \n" % std_1) resp.write("std2 is %2.10f \n" % std_2) resp.write( "Peak signal to noise ratio is %s \n" % peak_signal_to_noise_ratio) resp.write("Mean square error between the images is %s \n" % mse) resp.write( "Normalised root mean squre error between the images is %s \n" % rmse) resp.close()
def run_metrics(image_file_name1,image_file_name2 ): image_name1 = io.imread(image_file_name1) image_name2 = io.imread(image_file_name2) peak_signal_to_noise_ratio = measure.compare_psnr (image_name1,image_name2) print ("PSNR Peak signal to noise ratio is %s"%peak_signal_to_noise_ratio) mse = measure.compare_mse(image_name1,image_name2) print ("MSE Mean square error between the images is %s"%mse) rmse = measure.compare_nrmse(image_name1,image_name2) print ("RMSE Normalised root mean square error between the images is %s"%rmse) ssim = measure.compare_ssim(image_name1,image_name2, multichannel=True) print ("SSIM Structural Similarity Index is %s"%ssim) #[M3,M4] = minkowski_distance(image_name1,image_name2) #print ("Minkowski distance is %s %s"%(M3,M4)) #AD = average_difference(image_name1,image_name2) #print ("AD Average difference is %s"%AD) #SC = structural_content(image_name1,image_name2) #print ("SC Structural Content is %s"%SC) #NK = normalised_cross_correlation(image_name1,image_name2) #print ("NK normalised cross correlation is %s"%NK) #MD = maximum_difference(image_name1,image_name2) #print ("Maximum difference is %s"%MD) return {'peaktonoise':peak_signal_to_noise_ratio ,'mse': mse, 'rmse': rmse, 'ssim':ssim,'score':peak_signal_to_noise_ratio}
psnr_sum = 0 ssim_sum = 0 for i in range(14): image = scipy.misc.imread( '/home/wangyang/桌面/SRGAN/samples/evaluate/set14/%d/valid_gen%d.png' % (i, i)) image_true = scipy.misc.imread( '/home/wangyang/桌面/SRGAN/samples/evaluate/set14/%d/valid_hr%d.png' % (i, i)) y_image = convert_rgb_to_y(image, False) y_image_true = convert_rgb_to_y(image_true, False) print(np.array(y_image).shape) print(np.array(y_image_true).shape) ssim = measure.compare_ssim(np.array(y_image_true), np.array(y_image), win_size=11, gradient=False, multichannel=True, gaussian_weights=True, full=False, dynamic_range=255) psnr = measure.compare_psnr(np.array(y_image_true), np.array(y_image), True, 255) ssim_sum = ssim_sum + ssim psnr_sum = psnr_sum + psnr print(ssim) print(psnr) print("average ssim is %4.4f" % (ssim_sum / 14.0)) print("average psnr is %4.4f" % (psnr_sum / 14.0))
def test_PSNR_errors(): # shape mismatch with testing.raises(ValueError): compare_psnr(cam, cam[:-1, :])
def train(self, config, load_model_epoch, indx_, original_img, psrns, ssims, ssims_with_data_range): self.load(config.checkpoint_dir, load_model_epoch) config.is_train = False nx, ny, original_shape = input_setup(config) #print(" nx, ny, original_shape:", nx, ny, original_shape) data_dir = checkpoint_dir(config) #print("data_dir:", data_dir) input_, label_ = read_data(data_dir) print("Now Start Testing...") result = self.pred.eval({self.images: input_}) #print("result:", result.shape) #print(label_[1] - result[1]) image = merge(result, [nx, ny], self.c_dim) #print("image after merge:", image.shape) '''print("[nx, ny]:", [nx, ny]) print("original_shape:", original_shape) print(type(image), type(original_shape[0]), type(original_shape[1])) ''' cropped_img = crop_center(image, original_shape[0], original_shape[1]) #print("cropped_img:", cropped_img.shape) #image_LR = merge(input_, [nx, ny], self.c_dim) #checkimage(image_LR) #imsave(image, config.result_dir + '/result.png', config) #imsave(cropped_img, config.result_dir + '/result_crop.png', config) imsave( cropped_img, config.result_dir + '/srcnn-' + str(indx_) + '-epoch-' + str(load_model_epoch) + '.png', config) cropped_img = cropped_img * 255. cropped_img = cropped_img.astype(np.uint8) print(original_img.shape, original_img.dtype) print(cropped_img.shape, cropped_img.dtype) try: psnr = measure.compare_psnr(original_img, cropped_img) psrns.append(psnr) print(indx_, ", psnr:", psnr) ssim = computeSSIM( config.test_img, config.result_dir + '/srcnn-' + str(indx_) + '-epoch-' + str(load_model_epoch) + '.png') print(indx_, ", ssim:", ssim) ssims.append(ssim) ssim_with_data_range = computeSSIM_WithDataRange( config.test_img, config.result_dir + '/srcnn-' + str(indx_) + '-epoch-' + str(load_model_epoch) + '.png') print(indx_, ", ssim_with_data_range:", ssim_with_data_range) ssims_with_data_range.append(ssim_with_data_range) #os.remove(config.result_dir + '/srcnn-' + str(indx_) + '-epoch-' + str(load_model_epoch) + '.png') except: print("indx_:", indx_) print("Unexpected error while computing psnr / ssim:", sys.exc_info()[0])
np.arange(vol_dims[2]))) interpFunc = sciint.interpolate.RegularGridInterpolator((np.arange( vol_dims[0]), np.arange(vol_dims[1]), np.linspace(0, vol_dims[2], 3)), lo_vol[:, :, 2::4]) samp_grid = np.moveaxis(samp_grid, 0, -1) int_vol = interpFunc(samp_grid, method='linear') int_vol = np.swapaxes(int_vol, 0, 1) vol_L2 = np.sum(np.square(hi_vol - out_vol)) lo_MSE = sk.compare_mse(hi_vol, lo_vol) out_MSE = sk.compare_mse(hi_vol, out_vol) int_MSE = sk.compare_mse(hi_vol, int_vol) # lo_L2 = np.sum(np.square(hi_vol - lo_vol)) # out_L2 = np.sum(np.square(hi_vol - out_vol)) # int_L2 = np.sum(np.square(hi_vol - int_vol)) lo_pSNR = sk.compare_psnr(hi_vol, lo_vol) out_pSNR = sk.compare_psnr(hi_vol, out_vol) int_pSNR = sk.compare_psnr(hi_vol, int_vol) lo_SSIM = sk.compare_ssim(hi_vol, lo_vol) out_SSIM = sk.compare_ssim(hi_vol, out_vol) int_SSIM = sk.compare_ssim(hi_vol, int_vol) for idx in range(0, vol_dims[2]): lo_L2 = np.sum(np.square(hi_vol[:, :, idx] - lo_vol[:, :, idx])) out_L2 = np.sum(np.square(hi_vol[:, :, idx] - out_vol[:, :, idx])) int_L2 = np.sum(np.square(hi_vol[:, :, idx] - int_vol[:, :, idx])) print(hi_vol[:, :, idx].max(), hi_vol[:, :, idx].min()) print(lo_vol[:, :, idx].max(), lo_vol[:, :, idx].min()) print(out_vol[:, :, idx].max(), out_vol[:, :, idx].min()) print("\n")
def cal_psnr(img1, img2): img1 = img1.cpu() img2 = img2.cpu() img1_np = img1.detach().numpy() img2_np = img2.detach().numpy() return measure.compare_psnr(img1_np, img2_np)
lr_l = lr_loss(ds_in_tensor, lr_tensor) l2_l = l2_loss(in_tensor, org_tensor) l = lr_l + LAMBDA * l2_l l.backward() gradient = in_tensor.grad * LEARING_RATE if ATTENTION: gradient = gradient * attentioner(torch.abs(gradient) / torch.max(torch.abs(gradient))) in_tensor = in_tensor.data.sub_(gradient) in_tensor.requires_grad = True sr_img = torch.clamp(torch.round(in_tensor), 0., 255.).detach().cpu().numpy().astype(np.uint8) dsr_img = torch.clamp(torch.round(ds_in_tensor), 0., 255.).detach().cpu().numpy().astype(np.uint8) # sr_img = np.moveaxis(sr_img.reshape(np_ds.shape[1:]), 0, -1) psnr = compare_psnr(sr_img[0], hr_img) lr_psnr = compare_psnr(dsr_img[0], lr_img) report = 'Image Name: {} | Epoch: {:03d}| PSNR vHR: {:.4f} | LR-PSNR: {:.4f} |Time: {:.4f}'.format(IMG_NAME, epoch, psnr, lr_psnr, time() - begin_time) if epoch==0: print(report) psnr0 = psnr lr_psnr0 = lr_psnr elif epoch==NUM_EPOCH-1: print(report) psnrF = psnr lr_psnrF = lr_psnr f.write(report + "\n") # psnrs.append(float(psnr(hr_l))) # sr_img = torch.clamp(torch.round(in_tensor), 0., 255.).detach().cpu().numpy().astype(np.int16) # sr_img = rgb2ycbcr(sr_img.reshape(sr_img.shape[1:]))[CLIP:-CLIP, CLIP:-CLIP, 0] # psnr_dict[IMG_NAME].append(float(psnr(hr_l)))
else: result_RAISR = im_result[region] * 255 result_RAISR = result_RAISR.astype('uint8') ''' # Filtered result im_result = im_result * 255 im_result = np.rint(im_result).astype('uint8') # Bicubic result im_bicubic = im_bicubic * 255 im_bicubic = np.rint(im_bicubic).astype('uint8') # Blended result im_blending = im_blending * 255 im_blending = np.rint(im_blending).astype('uint8') # Measure reconstruction quality # Calculate PSNR values PSNR_bicubic = compare_psnr(imHR[region], im_bicubic[region]) PSNR_result = compare_psnr(imHR[region], im_result[region]) PSNR_blending = compare_psnr(imHR[region], im_blending[region]) PSNR_blending = max(PSNR_result, PSNR_blending) # Save RAISR reconstruction createFolder('./results/') #cv2.imwrite('results/' + os.path.splitext(os.path.basename(filelist[0][image]))[0] + '_result.bmp', result_RAISR) cv2.imwrite( 'results/' + os.path.splitext(os.path.basename(filelist[0][image]))[0] + '_bicubic.bmp', im_bicubic[region]) cv2.imwrite( 'results/' + os.path.splitext(os.path.basename(filelist[0][image]))[0] + '_result.bmp', im_result[region]) cv2.imwrite(
def test_PSNR_errors(): with pytest.raises(ValueError): compare_psnr(cam, cam.astype(np.float32)) with pytest.raises(ValueError): compare_psnr(cam, cam[:-1, :])
def func_enhance(dir_model_pre, QP, PreIndex_list, CmpIndex_list, SubIndex_list): """Enhance PQFs or non-PQFs, record dpsnr, dssim and enhanced frames.""" #ywz global ywz_times global enhanced_list, sum_dpsnr, sum_dssim tf.reset_default_graph() ### Defind enhancement process x1 = tf.placeholder(tf.float32, [BATCH_SIZE, height, width, CHANNEL]) # previous x2 = tf.placeholder(tf.float32, [BATCH_SIZE, height, width, CHANNEL]) # current x3 = tf.placeholder(tf.float32, [BATCH_SIZE, height, width, CHANNEL]) # subsequent if QP in net1_list: is_training = tf.placeholder_with_default(False, shape=()) x1to2 = warp_img(BATCH_SIZE, x2, x1, False) x3to2 = warp_img(BATCH_SIZE, x2, x3, True) if QP in net1_list: x2_enhanced = net_MFCNN.network(x1to2, x2, x3to2, is_training) else: x2_enhanced = net_MFCNN.network2(x1to2, x2, x3to2) saver = tf.train.Saver() with tf.Session(config = config) as sess: # ywz if ywz_times==0: options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) # # Restore model # model_path = os.path.join(dir_model_pre, "model_step2.ckpt-" + str(QP)) model_path = os.path.join(dir_model_pre, "model_step2.ckpt-0") # saver.restore(sess, model_path) module_file = tf.train.latest_checkpoint(model_path) # with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if module_file is not None: saver.restore(sess, module_file) nfs = len(CmpIndex_list) sum_dpsnr_part = 0.0 sum_dssim_part = 0.0 for ite_frame in range(nfs): # Load frames pre_frame = y_import(CmpVideo_path, height, width, 1, PreIndex_list[ite_frame])[:,:,:,np.newaxis] / 255.0 cmp_frame = y_import(CmpVideo_path, height, width, 1, CmpIndex_list[ite_frame])[:,:,:,np.newaxis] / 255.0 sub_frame = y_import(CmpVideo_path, height, width, 1, SubIndex_list[ite_frame])[:,:,:,np.newaxis] / 255.0 # if cmp frame is plane? if isplane(cmp_frame): continue # if PQF frames are plane? if isplane(pre_frame): pre_frame = np.copy(cmp_frame) if isplane(sub_frame): sub_frame = np.copy(cmp_frame) # ywz if ywz_times==0: run_metadata = tf.RunMetadata() # Enhance if QP in net1_list: enhanced_frame = sess.run(x2_enhanced,options = options, feed_dict={x1:pre_frame, x2:cmp_frame, x3:sub_frame, is_training:False}, run_metadata=run_metadata) else: enhanced_frame = sess.run(x2_enhanced,options = options, feed_dict={x1:pre_frame, x2:cmp_frame, x3:sub_frame}, run_metadata=run_metadata) else: # Enhance if QP in net1_list: enhanced_frame = sess.run(x2_enhanced, feed_dict={x1: pre_frame, x2: cmp_frame, x3: sub_frame,is_training: False}) else: enhanced_frame = sess.run(x2_enhanced, feed_dict={x1: pre_frame, x2: cmp_frame, x3: sub_frame}) # # ywz # timeline record # Create the Timeline object, and write it to a json file if ywz_times==0: fetched_timeline = timeline.Timeline(run_metadata.step_stats) chrome_trace = fetched_timeline.generate_chrome_trace_format() with open("timeline/timeline_" + str(ite_frame) + ".json", 'w') as f: f.write(chrome_trace) # # Record for output video enhanced_list[CmpIndex_list[ite_frame]] = np.squeeze(enhanced_frame) # Evaluate and accumulate dpsnr raw_frame = np.squeeze(y_import(RawVideo_path, height, width, 1, CmpIndex_list[ite_frame])) / 255.0 cmp_frame = np.squeeze(cmp_frame) enhanced_frame = np.squeeze(enhanced_frame) raw_frame = np.float32(raw_frame) cmp_frame = np.float32(cmp_frame) psnr_ori = compare_psnr(cmp_frame, raw_frame, data_range=1.0) psnr_aft = compare_psnr(enhanced_frame, raw_frame, data_range=1.0) ssim_ori = compare_ssim(cmp_frame, raw_frame, data_range=1.0) ssim_aft = compare_ssim(enhanced_frame, raw_frame, data_range=1.0) sum_dpsnr_part += psnr_aft - psnr_ori sum_dssim_part += ssim_aft - ssim_ori print("\r %d | %d at QP = %d" % (ite_frame + 1, nfs, QP), end="") #ywz ywz_times += 1 print(" ", end="\r") sum_dpsnr += sum_dpsnr_part sum_dssim += sum_dssim_part average_dpsnr = sum_dpsnr_part / nfs average_dssim = sum_dssim_part / nfs print("dPSNR: %.3f - dSSIM: %.3f - nfs: %4d" % (average_dpsnr, average_dssim, nfs), flush=True) file_object.write("dPSNR: %.3f - dSSIM: %.3f - nfs: %4d\n" % (average_dpsnr, average_dssim, nfs)) file_object.flush()
def accuracy(outputs, labels): N, _, _, _ = outputs.shape psnr = 0 for i in range(N): psnr += compare_psnr(labels[i], outputs[i]) return psnr / N
if len(img_clean.shape) == 2: net = Denoising_Net_gray() net.load_state_dict(t.load('./model/model_300.hdf5', 'cuda:0')) net.cuda() tensor_n = gray_tensor_generator(img_n) nlm = np.tile(sigma / 255.0, tensor_n[0].shape).astype(np.float32) # noise level map tensor_n.append(nlm) noisy = np.expand_dims(np.stack(tensor_n, axis=0), axis=0) noisy = t.from_numpy(noisy.copy()) img_denoised = net(noisy.cuda()) img_denoised = img_denoised.cpu().detach().numpy().squeeze() img_denoised = gray_reconstruction(img_denoised, wave_base) img_denoised = img_denoised[0:img_clean.shape[0], 0:img_clean.shape[1]] psnr = round(compare_psnr(img_denoised, img_clean, data_range=1), 3) ssim = round( compare_ssim(img_denoised, img_clean, data_range=1, multichannel=False), 3) print('PSNR: %.4f, SSIM: %.4f' % (psnr, ssim)) print('Test Image: ' + img_name + ' Noise Level: %d, PSNR: %.4f, SSIM: %.4f' % (sigma, psnr, ssim)) if Dir != 'RNI6': psnr = round(compare_psnr(img_denoised, img_clean, data_range=1), 3) ssim = round( compare_ssim(img_denoised, img_clean, data_range=1, multichannel=False), 3) print('PSNR: %.4f, SSIM: %.4f' % (psnr, ssim)) print('Test Image: ' + img_name +
ax[0, 1].set_title('non-local means\n(slow)') ax[0, 2].imshow(denoise2) ax[0, 2].axis('off') ax[0, 2].set_title('non-local means\n(slow, using $\sigma_{est}$)') ax[1, 0].imshow(astro) ax[1, 0].axis('off') ax[1, 0].set_title('original\n(noise free)') ax[1, 1].imshow(denoise_fast) ax[1, 1].axis('off') ax[1, 1].set_title('non-local means\n(fast)') ax[1, 2].imshow(denoise2_fast) ax[1, 2].axis('off') ax[1, 2].set_title('non-local means\n(fast, using $\sigma_{est}$)') fig.tight_layout() # print PSNR metric for each case psnr_noisy = compare_psnr(astro, noisy) psnr = compare_psnr(astro, denoise) psnr2 = compare_psnr(astro, denoise2) psnr_fast = compare_psnr(astro, denoise_fast) psnr2_fast = compare_psnr(astro, denoise2_fast) print("PSNR (noisy) = {:0.2f}".format(psnr_noisy)) print("PSNR (slow) = {:0.2f}".format(psnr)) print("PSNR (slow, using sigma) = {:0.2f}".format(psnr2)) print("PSNR (fast) = {:0.2f}".format(psnr_fast)) print("PSNR (fast, using sigma) = {:0.2f}".format(psnr2_fast)) plt.show()
def test(model): print('Start to test on {}'.format(args.test_dir)) out_dir = save_dir + args.test_dir.split('/')[-1] + '/' if not os.path.exists(out_dir): os.mkdir(out_dir) name = [] psnr = [] ssim = [] file_list = glob.glob( '{}/*'.format(args.test_dir) ) #notice: it is easy to generate error $201804101000tcw #notice; need to change the format for file in file_list: # read image img_clean = np.array(Image.open(file), dtype='float32') / 255.0 np.random.seed( 0 ) #obtain the same random data when it is in the test phase tcw201804151350 img_test = img_clean + np.random.normal(0, args.sigma / 255.0, img_clean.shape) img_test = img_test.astype('float32') # predict x_test = img_test.reshape( 1, img_test.shape[0], img_test.shape[1], 3 ) #if the last parameter is 1, the image is gray. If the last parameter is 3201807082123tcw y_predict = model.predict(x_test) #tcw # calculate numeric metrics img_out = y_predict.reshape(img_clean.shape) img_out = np.clip(img_out, 0, 1) psnr_noise, psnr_denoised = compare_psnr(img_clean, img_test, True), compare_psnr( img_clean, img_out, True) ssim_noise, ssim_denoised = compare_ssim( img_clean, img_test, multichannel=True), compare_ssim(img_clean, img_out, multichannel=True) psnr.append(psnr_denoised) ssim.append(ssim_denoised) # save images filename = file.split('/')[-1].split('.')[ 0] # get the name of image file name.append(filename) img_test = Image.fromarray((img_test * 255).astype('uint8')) img_test.save(out_dir + filename + '_sigma' + '{}_psnr{:.2f}.png'.format(args.sigma, psnr_noise)) img_out = Image.fromarray((img_out * 255).astype('uint8')) img_out.save(out_dir + filename + '_psnr{:.2f}.png'.format(psnr_denoised)) # print psnr_denoised # print len(psnr) #print sum(psnr) psnr_avg = sum(psnr) / len(psnr) ssim_avg = sum(ssim) / len(ssim) name.append('Average') psnr.append(psnr_avg) ssim.append(ssim_avg) print('Average PSNR = {0:.2f}, SSIM = {1:.2f}'.format(psnr_avg, ssim_avg)) pd.DataFrame({ 'name': np.array(name), 'psnr': np.array(psnr), 'ssim': np.array(ssim) }).to_csv(out_dir + '/metrics.csv', index=True)
from skimage.restoration import denoise_wavelet, cycle_spin from skimage import data, img_as_float from skimage.util import random_noise from skimage.measure import compare_psnr original = img_as_float(data.chelsea()[100:250, 50:300]) sigma = 0.155 noisy = random_noise(original, var=sigma**2) fig, ax = plt.subplots(nrows=2, ncols=3, figsize=(10, 4), sharex=False, sharey=False) ax = ax.ravel() psnr_noisy = compare_psnr(original, noisy) ax[0].imshow(noisy) ax[0].axis('off') ax[0].set_title('Noisy\nPSNR={:0.4g}'.format(psnr_noisy)) # Repeat denosing with different amounts of cycle spinning. e.g. # max_shift = 0 -> no cycle spinning # max_shift = 1 -> shifts of (0, 1) along each axis # max_shift = 3 -> shifts of (0, 1, 2, 3) along each axis # etc... denoise_kwargs = dict(multichannel=True, convert2ycbcr=True, wavelet='db1') all_psnr = [] max_shifts = [0, 1, 3, 5]
def psnr(gt, pred): """ Compute Peak Signal to Noise Ratio metric (PSNR) """ return compare_psnr(gt, pred, data_range=gt.max())
image = img_as_float(imread('parrots.jpg')) l = [] for i in range(len(image)): for j in range(len(image[0])): l.append(image[i][j]) clf = KMeans(n_clusters=10, random_state=241) clf.fit(l) pred = clf.predict(l) l = list(map(lambda x: x, l)) l1 = list(map(lambda x: clf.cluster_centers_[pred[x]], range(len(l)))) l2 = list(map(lambda x: to_rgb(clf.cluster_centers_[pred[x]]), range(len(l)))) print(compare_psnr(np.array(l), np.array(l1))) count = 0 l3 = [None] * len(image) for i in range(len(image)): l3[i] = [None] * len(image[i]) for j in range(len(image[i])): l3[i][j] = l2[count] for k in range(3): l3[i][j][k] = 255 - l3[i][j][k] count += 1 l3 = np.array(l3, np.int32) matplotlib.image.imsave('name.png', l3)
def test_PSNR_vs_IPOL(): # Tests vs. imdiff result from the following IPOL article and code: # http://www.ipol.im/pub/art/2011/g_lmii/ p_IPOL = 22.4497 p = compare_psnr(cam, cam_noisy) assert_almost_equal(p, p_IPOL, decimal=4)
def psnr(imageA, imageB): return compare_psnr(imageA, imageB)
for step in progress: optimizer.zero_grad() net_output = net(net_input) net_output_ds = ds_net(net_output) loss = MSE(net_output_ds, target) loss.backward() optimizer.step() train_loss = loss.data[0] if step % 100 == 0: if use_cuda: net_output = net_output.cpu() filename = None if args.output is None else '%s/%04d.png' % ( args.output, step) img = tensor_to_image(net_output.data, filename) psnr = compare_psnr(truth, np.array(img)) max_psnr = max(max_psnr, psnr) progress.set_description( 'Loss: %.6f | PSNR: %.2f dB | Max PSNR: %.2f dB' % (train_loss, psnr, max_psnr)) if use_cuda: noise_new = torch.cuda.FloatTensor(noise.shape).normal_(std=sigma) else: noise_new = torch.FloatTensor(noise.shape).normal_(std=sigma) net_input.data += noise_new
y = Q * np.random.poisson(im_lam).astype('float32') / 255.0 y_ = torch.from_numpy(y).view(1, -1, y.shape[0], y.shape[1]) torch.cuda.synchronize() start_time = time.time() y_ = y_.cuda() x_ = model(y_)[1] # inference x_ = x_.view(y.shape[0], y.shape[1]) x_ = x_.cpu() x_ = x_.detach().numpy().astype(np.float32) torch.cuda.synchronize() elapsed_time = time.time() - start_time print('%10s : %10s : %2.4f second' % (set_cur, im, elapsed_time)) psnr_x_ = compare_psnr(x, x_) ssim_x_ = compare_ssim(x, x_) if args.save_result: name, ext = os.path.splitext(im) if k < 10: show(np.hstack((y, x_, y - x_))) # show the image k = k + 1 save_result(x_, path=os.path.join( args.result_dir, set_cur, name + '_dncnn' + ext)) # save the denoised image psnrs.append(psnr_x_) ssims.append(ssim_x_) psnr_avg = np.mean(psnrs) ssim_avg = np.mean(ssims) psnrs.append(psnr_avg)
def main(lr, prefix, K, T, gpu): data_path = "../data/UCF101/UCF-101/" f = open(data_path.rsplit("/", 2)[0] + "/testlist01.txt", "r") testfiles = f.readlines() image_size = [240, 320] c_dim = 3 iters = 0 if prefix == "paper_models": checkpoint_dir = "../models/" + prefix + "/S1M/" best_model = "MCNET.model-102502" else: checkpoint_dir = "../models/" + prefix + "/" best_model = None # will pick last model with tf.device("/gpu:%d" % gpu[0]): model = MCNET(image_size=image_size, batch_size=1, K=K, T=T, c_dim=c_dim, checkpoint_dir=checkpoint_dir, is_train=False) gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5) with tf.Session(config=tf.ConfigProto(allow_soft_placement=True, log_device_placement=False, gpu_options=gpu_options)) as sess: tf.global_variables_initializer().run() loaded, model_name = model.load(sess, checkpoint_dir, best_model) if loaded: print(" [*] Load SUCCESS") else: print(" [!] Load failed... exitting") return quant_dir = "../results/quantitative/UCF101/" + prefix + "/" save_path = quant_dir + "results_model=" + model_name + ".npz" if not exists(quant_dir): makedirs(quant_dir) vid_names = [] psnr_err = np.zeros((0, T)) ssim_err = np.zeros((0, T)) for i in range(0, len(testfiles), 10): print(" Video " + str(i) + "/" + str(len(testfiles))) tokens = testfiles[i].split("/")[1].split() testfiles[i] = testfiles[i].replace("/HandStandPushups/", "/HandstandPushups/") vid_path = data_path + testfiles[i].split()[0] vid = imageio.get_reader(vid_path, "ffmpeg") folder_name = vid_path.split("/")[-1].split(".")[0] vid_names.append(folder_name) vid = imageio.get_reader(vid_path, "ffmpeg") savedir = "../results/images/UCF101/" + prefix + "/" + str(i + 1) seq_batch = np.zeros( (1, image_size[0], image_size[1], K + T, c_dim), dtype="float32") diff_batch = np.zeros((1, image_size[0], image_size[1], K - 1, 1), dtype="float32") for t in range(K + T): img = vid.get_data(t)[:, :, ::-1] seq_batch[0, :, :, t] = transform(img) for t in range(1, K): prev = inverse_transform(seq_batch[0, :, :, t - 1]) * 255 prev = cv2.cvtColor(prev.astype("uint8"), cv2.COLOR_BGR2GRAY) next = inverse_transform(seq_batch[0, :, :, t]) * 255 next = cv2.cvtColor(next.astype("uint8"), cv2.COLOR_BGR2GRAY) diff = next.astype("float32") - prev.astype("float32") diff_batch[0, :, :, t - 1] = diff[:, :, None] / 255. true_data = seq_batch[:, :, :, K:, :].copy() pred_data = np.zeros(true_data.shape, dtype="float32") xt = seq_batch[:, :, :, K - 1] pred_data[0] = sess.run(model.G, feed_dict={ model.diff_in: diff_batch, model.xt: xt }) if not os.path.exists(savedir): os.makedirs(savedir) cpsnr = np.zeros((K + T, )) cssim = np.zeros((K + T, )) pred_data = np.concatenate((seq_batch[:, :, :, :K], pred_data), axis=3) true_data = np.concatenate((seq_batch[:, :, :, :K], true_data), axis=3) for t in range(K + T): pred = (inverse_transform(pred_data[0, :, :, t]) * 255).astype("uint8") target = (inverse_transform(true_data[0, :, :, t]) * 255).astype("uint8") cpsnr[t] = measure.compare_psnr(pred, target) cssim[t] = ssim.compute_ssim(Image.fromarray(target), Image.fromarray(pred)) pred = draw_frame(pred, t < K) target = draw_frame(target, t < K) cv2.imwrite(savedir + "/pred_" + "{0:04d}".format(t) + ".png", pred) cv2.imwrite(savedir + "/gt_" + "{0:04d}".format(t) + ".png", target) cmd1 = "rm " + savedir + "/pred.gif" cmd2 = ("ffmpeg -f image2 -framerate 3 -i " + savedir + "/pred_%04d.png " + savedir + "/pred.gif") cmd3 = "rm " + savedir + "/pred*.png" # Comment out "system(cmd3)" if you want to keep the output images # Otherwise only the gifs will be kept system(cmd1) system(cmd2) system(cmd3) cmd1 = "rm " + savedir + "/gt.gif" cmd2 = ("ffmpeg -f image2 -framerate 3 -i " + savedir + "/gt_%04d.png " + savedir + "/gt.gif") cmd3 = "rm " + savedir + "/gt*.png" # Comment out "system(cmd3)" if you want to keep the output images # Otherwise only the gifs will be kept system(cmd1) system(cmd2) system(cmd3) psnr_err = np.concatenate((psnr_err, cpsnr[None, K:]), axis=0) ssim_err = np.concatenate((ssim_err, cssim[None, K:]), axis=0) np.savez(save_path, psnr=psnr_err, ssim=ssim_err) print("Results saved to " + save_path) print("Done.")
def main(args): image_number=0; model = SARGAN(img_size, BATCH_SIZE, img_channel=img_size[2]) with tf.variable_scope("d_opt",reuse=tf.AUTO_REUSE): d_opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE).minimize(model.d_loss, var_list=model.d_vars) with tf.variable_scope("g_opt",reuse=tf.AUTO_REUSE): g_opt = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE).minimize(model.g_loss, var_list=model.g_vars) if(retrain==0): saver = tf.train.Saver(max_to_keep=20) else: saver = tf.train.import_meta_graph(trained_model_path+'/sargan_mnist.meta'); gpu_options = tf.GPUOptions(allow_growth=True, visible_device_list=str(GPU_ID)) config = tf.ConfigProto(gpu_options=gpu_options) progress_bar = tqdm(range(MAX_EPOCH), unit="epoch") #list of loss values each item is the loss value of one ieteration train_d_loss_values = [] train_g_loss_values = [] #test_imgs, test_classes = get_data(test_filename) #imgs, classes = get_data(train_filename) with tf.Session(config=config) as sess: if(retrain==0): sess.run(tf.global_variables_initializer()) else: sess.run(tf.global_variables_initializer()) saver.restore(sess,tf.train.latest_checkpoint(trained_model_path)); #test_copies = test_imgs.astype('float32') for epoch in progress_bar: NUM_TEST_PER_EPOCH = 1 counter = 0 epoch_start_time = time.time() encoded_data, original_data, val_data, val_original=transfrom_data(NUM_TEST_PER_EPOCH) #shuffle(copies) #divide the images into equal sized batches #image_batches = np.array(list(chunks(copies, BATCH_SIZE))) for i in range (NUM_ITERATION): #getting a batch from the training data #one_batch_of_imgs = image_batches[i] #copy the batch features=original_data[i] #corrupt the images corrupted_batch = encoded_data[i] _, m = sess.run([d_opt, model.d_loss], feed_dict={model.image:features, model.cond:corrupted_batch}) _, M = sess.run([g_opt, model.g_loss], feed_dict={model.image:features, model.cond:corrupted_batch}) train_d_loss_values.append(m) train_g_loss_values.append(M) #print some notifications counter += 1 if counter % 25 == 0: print("\rEpoch [%d], Iteration [%d]: time: %4.4f, d_loss: %.8f, g_loss: %.8f" \ % (epoch, counter, time.time() - epoch_start_time, m, M)) # save the trained network if epoch % SAVE_EVERY_EPOCH == 0: save_path = saver.save(sess, (trained_model_path+"/sargan_mnist")) print("\n\nModel saved in file: %s\n\n" % save_path) ''' +\ "%s_model_%s.ckpt" % ( experiment_name, epoch+1))''' ##### TESTING FOR CURRUNT EPOCH #test_batches = np.array(list(chunks(test_copies, BATCH_SIZE))) #test_images = test_batches[0] sum_psnr = 0 list_images = [] for j in range(NUM_TEST_PER_EPOCH): features=val_original[j] #corrupt the images corrupted_batch = val_data[j] gen_imgs = sess.run(model.gen_img, feed_dict={model.image:features, model.cond:corrupted_batch}) print(features.shape, gen_imgs.shape) #if j %17 == 0: # only save 3 images 0, 17, 34 list_images.append((features[0], corrupted_batch[0], gen_imgs[0])) list_images.append((features[17], corrupted_batch[17], gen_imgs[17])) list_images.append((features[34], corrupted_batch[34], gen_imgs[34])) for i in range(len(gen_imgs)): current_img = features[i] recovered_img = gen_imgs[i] sum_psnr += ski_me.compare_psnr(current_img, recovered_img, 1) #psnr_value = ski_mem.compare_psnr(test_img, gen_img, 1) #sum_psnr += psnr_value average_psnr = sum_psnr / 50 epoch_running_time = time.time() - epoch_start_time ############### SEND EMAIL ############## rows = 1 cols = 3 display_mean = np.array([0.485, 0.456, 0.406]) display_std = np.array([0.229, 0.224, 0.225]) if epoch % SAVE_EVERY_EPOCH == 0: #image = std * image + mean imgs_1 = list_images[0] imgs_2 = list_images[1] imgs_3 = list_images[2] imgs_1 = display_std * imgs_1 + display_mean imgs_2 = display_std * imgs_2 + display_mean imgs_3 = display_std * imgs_3 + display_mean fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_1[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_1[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_1[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_1 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_1.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_1 = os.path.join(output_path, 'image_%d_1.jpg' % image_number) plt.savefig(sample_test_file_1, dpi=300) fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_2[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_2[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_2[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_2 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_2.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_2 = os.path.join(output_path, 'image_%d_2.jpg' % image_number) plt.savefig(sample_test_file_2, dpi=300) fig = plt.figure(figsize=(14, 4)) ax = fig.add_subplot(rows, cols, 1) ax.imshow(imgs_3[0]) ax.set_title("Original", color='grey') ax = fig.add_subplot(rows, cols, 2) ax.imshow(imgs_3[1]) ax.set_title("Corrupted", color='grey') ax = fig.add_subplot(rows, cols, 3) ax.imshow(imgs_3[2]) ax.set_title("Recovered", color='grey') plt.tight_layout() #sample_test_file_3 = os.path.join(output_path, '%s_epoch_%s_batchsize_%s_3.jpg' % (experiment_name, epoch, BATCH_SIZE)) sample_test_file_3 = os.path.join(output_path, 'image_%d_3.jpg' % image_number) image_number+=1 plt.savefig(sample_test_file_3, dpi=300) plt.close("all")
sr_ssim_total = 0.0 sr_psnr_total = 0.0 with open(RES_DIR + "qual.txt", 'w') as fp: fp.write("") for i in range(image_num): sk_io.imsave(RES_DIR + "sr_img_{0:02d}.png".format(i), sr_img[i]) bc_ssim, sr_ssim = 0.0, 0.0 for c in range(3): bc_ssim += sk_ms.compare_ssim(hr_img[i][:, :, c], bc_img[i][:, :, c]) sr_ssim += sk_ms.compare_ssim(hr_img[i][:, :, c], sr_img[i][:, :, c]) bc_ssim /= 3.0 sr_ssim /= 3.0 prog_bar(i * 2 + 1, image_num * 2) bc_psnr = sk_ms.compare_psnr(hr_img[i], bc_img[i]) sr_psnr = sk_ms.compare_psnr(hr_img[i], sr_img[i]) prog_bar(i * 2 + 2, image_num * 2) with open(RES_DIR + "qual.txt", 'a') as fp: fp.write("[Image {:d}]\n".format(i)) fp.write(" bicubic: {0:f} {1:f}\n".format(bc_ssim, bc_psnr)) fp.write(" superres: {0:f} {1:f}\n".format(sr_ssim, sr_psnr)) bc_ssim_total += bc_ssim bc_psnr_total += bc_psnr sr_ssim_total += sr_ssim sr_psnr_total += sr_psnr bc_ssim_total /= image_num bc_psnr_total /= image_num sr_ssim_total /= image_num sr_psnr_total /= image_num with open(RES_DIR + "qual.txt", 'a') as fp:
num_ch=num_ch, reg_noise_std=args.reg_noise_std, n_ch_down=args.n_ch_down, n_ch_up=args.n_ch_up, skip_conn=args.skip_conn, depth=args.depth, act_fun=args.act_fun, upsample=args.upsample, linear=args.linear) traj_set.append(T) T1, T2 = traj_set # Find the best PSNR in the trajectory if not (args.clean_img is None): clean_img = utils.imread(args.clean_img) t1_psnr = [compare_psnr(clean_img, t1) for t1 in T1] best_psnr = np.max(t1_psnr) best_itr = np.argmax(t1_psnr) best_psnr_pred = T1[best_itr] print('Best PSNR: ' + str(best_psnr)) # Show initial, best and final points on the trajectory if num_ch == 1: plt.imshow(T1[0], cmap='gray') else: plt.imshow(T1[0]) plt.title('Initial output') plt.savefig(os.path.join(output_dir, 'init.png')) plt.close() if num_ch == 1: plt.imshow(T1[-1], cmap='gray')
img_pred = (imread(path_pred + '/' + basename(str(fn))) / 255.0).astype( np.float32) img_gt = rgb2gray(img_gt) img_pred = rgb2gray(img_pred) if args.debug != 0: plt.subplot('121') plt.imshow(img_gt) plt.title('Groud truth') plt.subplot('122') plt.imshow(img_pred) plt.title('Output') plt.show() psnr.append(compare_psnr(img_gt, img_pred, data_range=1)) ssim.append(compare_ssim(img_gt, img_pred, data_range=1, win_size=51)) mae.append(compare_mae(img_gt, img_pred)) if np.mod(index, 100) == 0: print( str(index) + ' images processed', "PSNR: %.4f" % round(np.mean(psnr), 4), "SSIM: %.4f" % round(np.mean(ssim), 4), "MAE: %.4f" % round(np.mean(mae), 4), ) index += 1 np.savez(args.output_path + '/metrics.npz', psnr=psnr, ssim=ssim, mae=mae,
final_preds = {b: None for b in baselines.keys()} traj_files = utils.traj_file_list(output_dir) for f in traj_files: hyp_str = utils.extract_hyp_str(f) noisy_output = utils.fname_with_hparams(output_dir, 'T_noisy.npz', hyp_str) noisy_T = utils.load_traj(noisy_output) # find pred. best iteration with different baselines for b in baselines.keys(): best_iter_pred = baselines[b]['func'](noisy_im, noisy_T) best_rec_pred = noisy_T[best_iter_pred] best_err_pred = ((im - best_rec_pred)**2).sum() best_psnr_pred = compare_psnr(best_rec_pred.astype(im.dtype), im) if best_err_pred < baselines[b]['res']['pred_best_err']: baselines[b]['res']['pred_best_psnr'] = float(best_psnr_pred) baselines[b]['res']['pred_best_hyp'] = hyp_str baselines[b]['res']['pred_best_iter'] = int( (best_iter_pred + 1) * traj_iter) final_preds[b] = best_rec_pred # save final results and best predicted denoised image for b in baselines.keys(): save_dir = baselines[b]['save_dir'] with open(os.path.join(save_dir, 'res.json'), 'w') as f: f.write(json.dumps(baselines[b]['res'], indent=2)) f.close()
def eval(self, epoch, loss_epoch): print('Evaluating on the validation set...') psnr_all = 0 ssim_all = 0 count = 0 for video_index in range(0, len(self.eval_frame_data_LR)): cur_video_LR = self.eval_frame_data_LR[video_index] path, _ = os.path.split(cur_video_LR[0]) _, name = os.path.split(path) cur_video_HR = self.eval_frame_data_HR[video_index] max_frame = len(cur_video_LR) # temp_img = cv2_imread(cur_video_LR[0]) # h,w,_ = temp_img.shape # L_eval = tf.placeholder(tf.float32, shape=[1, self.num_frames, h, w, 3], name='L_test') # SR_test = self.forward(L_eval) for i in range(max_frame): start_time = time.time() count += 1 index = np.array([ i for i in range(i - self.num_frames // 2, i + self.num_frames // 2 + 1) ]) index = np.clip(index, 0, max_frame - 1).tolist() lrs = np.array([cv2_imread(cur_video_LR[i]) for i in index]) / 255.0 lrs = lrs.astype('float32') lrs = np.expand_dims(lrs, 0) sr = self.sess.run(self.SR_test, feed_dict={self.L_test: lrs}) sr = sr * 255 sr = np.squeeze(sr, axis=(0)) sr = np.clip(sr, 0, 255) sr = np.round(sr, 0).astype(np.uint8) hr = cv2_imread(cur_video_HR[i]) psnr = compare_psnr(sr, hr) ssim = compare_ssim(sr, hr, multichannel=True) psnr_all += psnr ssim_all += ssim cost_time = time.time() - start_time print( '[*Epoch:{:05d}] val video:{} -> frame:{:05d}, psnr={:.4f}, ssim={:.4f}, cost time={:.2f} ' .format(epoch, name, i, psnr, ssim, cost_time)) a_psnr = psnr_all / count a_ssim = ssim_all / count eval_ss = self.sess.run(self.merge_op_eval, feed_dict={ self.loss_epoch: loss_epoch, self.psnr_eval: a_psnr, self.ssim_eval: a_ssim }) self.writer.add_summary(eval_ss, epoch) print( '{' + '"Epoch": {:05d} , "Training Loss":{:.6f}, " Eval PSNR": {:.4f}, "Eval SSIM": {:.4f}' .format(epoch, loss_epoch, a_psnr, a_ssim) + '}') # write to log file with open(self.log_dir, 'a+') as f: f.write( '{' + '"Epoch": {:05d} , "Training Loss":{:.6f}, " Eval PSNR": {:.4f}, "Eval SSIM": {:.4f}' .format(epoch, loss_epoch, a_psnr, a_ssim) + '}\n')
if gencount >= args.images: continue generated[gencount] = np.array(io.imread(os.path.join(start_path, filename), as_grey = True)) print(os.path.join(start_path, filename), gencount) gencount += 1 elif (filename.startswith('interpolated') and filename.endswith('%03d.png'%(intcount))): if intcount >= args.images: continue interpolated[intcount] = np.array(io.imread(os.path.join(start_path, filename), as_grey = True)) print(os.path.join(start_path, filename), intcount) intcount += 1 psnrint = np.zeros(args.images) psnrgen = np.zeros(args.images) print(np.max(highres)) print(np.max(interpolated)/255) print(np.max(generated)) for i in range(args.images): psnrint[i] = compare_psnr(highres[i], interpolated[i]/255) psnrgen[i] = compare_psnr(highres[i], generated[i]) fig = plt.figure() plt.plot(np.array([i+1 for i in range(args.images)]),psnrint) plt.plot(np.array([i+1 for i in range(args.images)]), psnrgen) plt.legend(['PSNR of Interpolated', 'PSNR of Generated']) plt.title('PSNR Value per Epoch for Select Sample') plt.xlabel('Epoch') plt.ylabel('PSNR (High is better image)') plt.show() fig.savefig('PSNROverEpochs.png', dpi = fig.dpi)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-c', '--continue', dest='continue_path', required=False) args = parser.parse_args() ## load dataset train_batch_gnr, train_set = get_dataset_batch(ds_name='train') test_gnr, test_set = get_dataset_batch(ds_name = 'test') ## build graph network = Model() placeholders, restored = network.build() gt = tf.placeholder(tf.float32, shape=(None, )+ (config.patch_size, config.patch_size)+ (config.nr_channel,), name = 'gt') loss_squared = squared_error_loss(gt, restored) loss_reg = tf.add_n(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)) loss = loss_reg + loss_squared ## train config global_steps = tf.Variable(0, trainable=False) boundaries = [train_set.minibatchs_per_epoch*20, train_set.minibatchs_per_epoch*50] values = [0.001, 0.0001, 0.00005] lr = tf.train.piecewise_constant(global_steps, boundaries, values) opt = tf.train.AdamOptimizer(lr) # in order to update BN in every iter update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train = opt.minimize(loss) ## init tensorboard tf.summary.scalar('loss_regularization', loss_reg) tf.summary.scalar('loss_error', loss - loss_reg) tf.summary.scalar('loss', loss) tf.summary.scalar('learning_rate', lr) merged = tf.summary.merge_all() train_writer = tf.summary.FileWriter(os.path.join(config.log_dir, 'tf_log', 'train'), tf.get_default_graph()) ## create a session tf.set_random_seed(12345) # ensure consistent results global_cnt = 0 epoch_start = 0 g_list = tf.global_variables() saver = tf.train.Saver(var_list=g_list) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if args.continue_path: ckpt = tf.train.get_checkpoint_state(args.continue_path) saver.restore(sess, ckpt.model_checkpoint_path) epoch_start = int(ckpt.model_checkpoint_path.split('/')[-1].split('-')[1]) global_cnt = epoch_start * train_set.minibatchs_per_epoch ## training for epoch in range(epoch_start+1, config.nr_epoch+1): for _ in range(train_set.minibatchs_per_epoch): global_cnt += 1 images, gt_images = sess.run(train_batch_gnr) feed_dict = { placeholders['data']: images, gt: gt_images, global_steps: global_cnt, placeholders['is_training']: True, } _, loss_v, loss_reg_v, lr_v, summary = sess.run([train, loss, loss_reg, lr, merged], feed_dict=feed_dict) if global_cnt % config.show_interval == 0: train_writer.add_summary(summary, global_cnt) print( "e:{},{}/{}".format(epoch, global_cnt % train_set.minibatchs_per_epoch, train_set.minibatchs_per_epoch), 'loss: {:.3f}'.format(loss_v), 'loss_reg: {:.3f}'.format(loss_reg_v), 'lr: {:.4f}'.format(lr_v), ) ## save model if epoch % config.snapshot_interval == 0: saver.save(sess, os.path.join(config.log_model_dir, 'epoch-{}'.format(epoch)), global_step=global_cnt) if epoch % config.test_interval == 0: psnrs = [] for _ in range(test_set.testing_minibatchs_per_epoch): image, gt_image = sess.run(test_gnr) feed_dict = { placeholders['data']: image, placeholders['is_training']: False, } restored_v = sess.run([restored],feed_dict = feed_dict) psnr_x = compare_psnr(gt_image[0,:,:,::-1], restored_v[0][0, :, :, ::-1]) psnrs.append(psnr_x) print('average psnr is {:2.2f} dB'.format(np.mean(psnrs))) print('Training is done, exit.')
im_visushrink = denoise_wavelet(noisy, multichannel=True, convert2ycbcr=True, method='VisuShrink', mode='soft', sigma=sigma_est) # VisuShrink is designed to eliminate noise with high probability, but this # results in a visually over-smooth appearance. Repeat, specifying a reduction # in the threshold by factors of 2 and 4. im_visushrink2 = denoise_wavelet(noisy, multichannel=True, convert2ycbcr=True, method='VisuShrink', mode='soft', sigma=sigma_est/2) im_visushrink4 = denoise_wavelet(noisy, multichannel=True, convert2ycbcr=True, method='VisuShrink', mode='soft', sigma=sigma_est/4) # Compute PSNR as an indication of image quality psnr_noisy = compare_psnr(original, noisy) psnr_bayes = compare_psnr(original, im_bayes) psnr_visushrink = compare_psnr(original, im_visushrink) psnr_visushrink2 = compare_psnr(original, im_visushrink2) psnr_visushrink4 = compare_psnr(original, im_visushrink4) ax[0, 0].imshow(noisy) ax[0, 0].axis('off') ax[0, 0].set_title('Noisy\nPSNR={:0.4g}'.format(psnr_noisy)) ax[0, 1].imshow(im_bayes) ax[0, 1].axis('off') ax[0, 1].set_title( 'Wavelet denoising\n(BayesShrink)\nPSNR={:0.4g}'.format(psnr_bayes)) ax[0, 2].imshow(im_visushrink) ax[0, 2].axis('off') ax[0, 2].set_title(
def closure(): global i, net_input, psnr_max, psnr_noisy_max, files_name, noisy_np, TEST_PLAN, test_torch_list, test_np_list global TRAIN_PLAN, noisy_np_norm, sigma_now, final_ssim, files_name, test_np_list, test_torch_list global psnr_2_5_max, final_ssim_max_5, psnr_2_10_max, final_ssim_max_10, psnr_2_15_max, final_ssim_max_15 global psnr_2_20_max, final_ssim_max_20, psnr_2_25_max, final_ssim_max_25, img_aug_np,SAVE_MODEL_FLAG, multilevel_noise_train out_effect_np = [] img_noisy_pil=[] img_noisy_np =[] img_noisy_torch=[] img_noisy_noisy_np = [] img_noisy_noisy_pil =[] img_noisy_noisy_torch = [] if multilevel_noise_train: min_log = np.log([0.0001]) sigma_s = min_log + np.random.rand(1) * (np.log([sigma_now]) - min_log) sigma_s = np.exp(sigma_s) noisy_np = noisy_np_norm * sigma_s noisy_torch = np_to_torch(noisy_np) else: noisy_np = noisy_np_norm * sigma_now noisy_torch = np_to_torch(noisy_np) for idx in range(len(net_input)): img_noisy_pil_, img_noisy_np_, img_noisy_noisy_pil_, img_noisy_noisy_np_ = \ get_noisy_noisy_image_with_noise(noisy_np, img_aug_np[idx]) img_noisy_torch_ = np_to_torch(img_noisy_np_).type(dtype) img_noisy_noisy_torch_ = np_to_torch(img_noisy_noisy_np_).type(dtype) img_noisy_pil.append(img_noisy_pil_) img_noisy_np.append(img_noisy_np_) img_noisy_torch.append(img_noisy_torch_) img_noisy_noisy_np.append(img_noisy_noisy_np_) img_noisy_noisy_pil.append(img_noisy_noisy_pil_) img_noisy_noisy_torch.append(img_noisy_noisy_torch_) for aug in range(len(img_noisy_torch)): out = net(img_noisy_noisy_torch[aug]) total_loss = mse(out, img_noisy_torch[aug]) total_loss.backward() psrn_noisy = compare_psnr(np.clip(img_noisy_np[aug], 0, 1), out.detach().cpu().numpy()[0]) do_i_learned_noise = img_noisy_noisy_np[aug] - out.detach().cpu().numpy()[0] mse_what_tf = MSE(noisy_np, do_i_learned_noise) if psnr_noisy_max == 0: psnr_noisy_max = psrn_noisy elif psnr_noisy_max < psrn_noisy: psnr_noisy_max = psrn_noisy if SAVE_DURING_TRAINING and i % save_every == 0: # output_dir out_test_np = torch_to_np(out) # I +N1 # out_test_name = f'{i}_test' # save_image(out_test_name, np.clip(out_test_np, 0, 1), output_path=output_dir) net.eval() with torch.no_grad(): out_effect_np_ = torch_to_np(net(img_noisy_torch[aug])) out_effect_np.append(out_effect_np_) psnr_1 = compare_psnr(img_aug_np[aug], np.clip(out_effect_np_, 0, 1)) test_do_i_learned_noise = img_noisy_np[aug] - out_effect_np_ test_what_tf = MSE(noisy_np, test_do_i_learned_noise) writer.add_scalar('scalar_noisy_psnr', psrn_noisy, i) writer.add_scalar('scalar_test_psnr', psnr_1, i) if psnr_max == 0: psnr_max = psnr_1 elif psnr_max < psnr_1: psnr_max = psnr_1 # print('%s Iteration %05d lr: %f, Loss %f , PSNR_noisy: %f, PSNR_noisy_max: %f, noise mse: %f,' # 'test psnr: %f , test max psnr: %f, test noise mse: %f , current sigma: %f ' % # (files_name, i, LR, total_loss.item(), psrn_noisy, psnr_noisy_max, mse_what_tf, psnr_1, psnr_max, # test_what_tf, sigma_s * 255)) if i % 10 == 0: SAVE_MODEL_FLAG = False net.eval() with torch.no_grad(): real_test_effect_np = [] for idxt in range(len(test_torch_list)): test_out_effect_np = torch_to_np(net(test_torch_list[idxt].type(dtype))) real_test_effect_np.append(test_out_effect_np) # psnr_1 = compare_psnr(img_np, np.clip(out_effect_np, 0, 1)) # test_do_i_learned_noise = torch_to_np(img_noisy_np[aug]) - test_out_effect_np print('%s Iteration %05d lr: %f, Loss %f , PSNR_noisy: %f, PSNR_noisy_max: %f, noise mse: %f,' 'test psnr: %f , test max psnr: %f, test noise mse: %f , current sigma: %f ' % (files_name, i, LR, total_loss.item(), psrn_noisy, psnr_noisy_max, mse_what_tf, psnr_1, psnr_max, test_what_tf, sigma_s * 255)) # sigma = 5 test_out_effect_np_5 = real_test_effect_np[0:8] test_out_effect_np_5[0] = test_out_effect_np_5[0].transpose(1, 2, 0) for aug in range(1, 8): if aug < 4: test_out_effect_np_5[aug] = np.rot90(test_out_effect_np_5[aug].transpose(1, 2, 0), 4-aug) else: test_out_effect_np_5[aug] = np.flipud(np.rot90(test_out_effect_np_5[aug].transpose(1, 2, 0), 8-aug)) final_reuslt_5 = np.mean(test_out_effect_np_5, 0) psnr_2_5 = compare_psnr(torch_to_np(net_input[0]).transpose(1, 2, 0), np.clip(final_reuslt_5, 0, 1)) final_ssim_5 = compare_ssim(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_5, 0, 1), data_range=1, multichannel=True) if psnr_2_5_max==0: psnr_2_5_max = psnr_2_5 final_ssim_max_5 = final_ssim_5 SAVE_MODEL_FLAG = True elif psnr_2_5_max< psnr_2_5: psnr_2_5_max = psnr_2_5 final_ssim_max_5 = final_ssim_5 SAVE_MODEL_FLAG = True tmp_name_p_5 = f'{files_name[:-4]}_{TEST_PLAN[0]}_{psnr_2_5:.2f}_final_{final_ssim_5:.4f}' save_image(tmp_name_p_5, np.clip(final_reuslt_5.transpose(2, 0, 1), 0, 1), output_path=output_dir) print('psnr 2_5: %f, psnr 2_5 max: %f, final ssim_5 : %f, final ssim max_5: %f' %(psnr_2_5, psnr_2_5_max, final_ssim_5, final_ssim_max_5)) # sigma = 10 test_out_effect_np_10 = real_test_effect_np[8:16] test_out_effect_np_10[0] = test_out_effect_np_10[0].transpose(1, 2, 0) for aug in range(1, 8): if aug < 4: test_out_effect_np_10[aug] = np.rot90(test_out_effect_np_10[aug].transpose(1, 2, 0), 4 - aug) else: test_out_effect_np_10[aug] = np.flipud(np.rot90(test_out_effect_np_10[aug].transpose(1, 2, 0), 8 - aug)) final_reuslt_10 = np.mean(test_out_effect_np_10, 0) psnr_2_10 = compare_psnr(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_10, 0, 1)) final_ssim_10 = compare_ssim(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_10, 0, 1), data_range=1, multichannel=True) if psnr_2_10_max == 0: psnr_2_10_max = psnr_2_10 final_ssim_max_10 = final_ssim_10 SAVE_MODEL_FLAG = True elif psnr_2_10_max < psnr_2_10: psnr_2_10_max = psnr_2_10 final_ssim_max_10 = final_ssim_10 SAVE_MODEL_FLAG = True tmp_name_p_10 = f'{files_name[:-4]}_{TEST_PLAN[1]}_{psnr_2_10:.2f}_final_{final_ssim_10:.4f}' save_image(tmp_name_p_10, np.clip(final_reuslt_10.transpose(2, 0, 1), 0, 1), output_path=output_dir) print('psnr 2_10: %f, psnr 2_10 max: %f, final ssim_10 : %f, final ssim max_10: %f' % (psnr_2_10, psnr_2_10_max, final_ssim_10, final_ssim_max_10)) # sigma = 15 test_out_effect_np_15 = real_test_effect_np[16:24] test_out_effect_np_15[0] = test_out_effect_np_15[0].transpose(1, 2, 0) for aug in range(1, 8): if aug < 4: test_out_effect_np_15[aug] = np.rot90(test_out_effect_np_15[aug].transpose(1, 2, 0), 4 - aug) else: test_out_effect_np_15[aug] = np.flipud(np.rot90(test_out_effect_np_15[aug].transpose(1, 2, 0), 8 - aug)) final_reuslt_15 = np.mean(test_out_effect_np_15, 0) psnr_2_15 = compare_psnr(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_15, 0, 1)) final_ssim_15 = compare_ssim(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_15, 0, 1), data_range=1, multichannel=True) if psnr_2_15_max == 0: psnr_2_15_max = psnr_2_15 final_ssim_max_15 = final_ssim_15 SAVE_MODEL_FLAG = True elif psnr_2_15_max < psnr_2_15: psnr_2_15_max = psnr_2_15 final_ssim_max_15 = final_ssim_15 SAVE_MODEL_FLAG = True tmp_name_p_15 = f'{files_name[:-4]}_{TEST_PLAN[2]}_{psnr_2_15:.2f}_final_{final_ssim_15:.4f}' save_image(tmp_name_p_15, np.clip(final_reuslt_15.transpose(2, 0, 1), 0, 1), output_path=output_dir) print('psnr 2_15: %f, psnr 2_15 max: %f, final ssim_15 : %f, final ssim max_15: %f' % (psnr_2_15, psnr_2_15_max, final_ssim_15, final_ssim_max_15)) # sigma = 20 test_out_effect_np_20 = real_test_effect_np[24:32] test_out_effect_np_20[0] = test_out_effect_np_20[0].transpose(1, 2, 0) for aug in range(1, 8): if aug < 4: test_out_effect_np_20[aug] = np.rot90(test_out_effect_np_20[aug].transpose(1, 2, 0), 4 - aug) else: test_out_effect_np_20[aug] = np.flipud(np.rot90(test_out_effect_np_20[aug].transpose(1, 2, 0), 8 - aug)) # final_reuslt = np.median(out_effect_np, 0) final_reuslt_20 = np.mean(test_out_effect_np_20, 0) psnr_2_20 = compare_psnr(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_20, 0, 1)) final_ssim_20 = compare_ssim(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_20, 0, 1), data_range=1, multichannel=True) if psnr_2_20_max == 0: psnr_2_20_max = psnr_2_20 final_ssim_max_20 = final_ssim_20 SAVE_MODEL_FLAG = True elif psnr_2_20_max < psnr_2_20: psnr_2_20_max = psnr_2_20 final_ssim_max_20 = final_ssim_20 SAVE_MODEL_FLAG = True tmp_name_p_20 = f'{files_name[:-4]}_{TEST_PLAN[3]}_{psnr_2_20:.2f}_final_{final_ssim_20:.4f}' save_image(tmp_name_p_20, np.clip(final_reuslt_20.transpose(2, 0, 1), 0, 1), output_path=output_dir) print('psnr 2_20: %f, psnr 2_20 max: %f, final ssim_20 : %f, final ssim max_20: %f' % (psnr_2_20, psnr_2_20_max, final_ssim_20, final_ssim_max_20)) # sigma = 25 test_out_effect_np_25 = real_test_effect_np[32:40] test_out_effect_np_25[0] = test_out_effect_np_25[0].transpose(1, 2, 0) for aug in range(1, 8): if aug < 4: test_out_effect_np_25[aug] = np.rot90(test_out_effect_np_25[aug].transpose(1, 2, 0), 4 - aug) else: test_out_effect_np_25[aug] = np.flipud(np.rot90(test_out_effect_np_25[aug].transpose(1, 2, 0), 8 - aug)) # final_reuslt = np.median(out_effect_np, 0) final_reuslt_25 = np.mean(test_out_effect_np_25, 0) psnr_2_25 = compare_psnr(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_25, 0, 1)) final_ssim_25 = compare_ssim(img_aug_np[0].transpose(1, 2, 0), np.clip(final_reuslt_25, 0, 1), data_range=1, multichannel=True) if psnr_2_25_max == 0: psnr_2_25_max = psnr_2_25 final_ssim_max_25 = final_ssim_25 SAVE_MODEL_FLAG = True elif psnr_2_25_max < psnr_2_25: psnr_2_25_max = psnr_2_25 final_ssim_max_25 = final_ssim_25 SAVE_MODEL_FLAG = True tmp_name_p_25 = f'{files_name[:-4]}_{TEST_PLAN[4]}_{psnr_2_25:.2f}_final_{final_ssim_25:.4f}' save_image(tmp_name_p_25, np.clip(final_reuslt_25.transpose(2, 0, 1), 0, 1), output_path=output_dir) print('psnr 2_25: %f, psnr 2_25 max: %f, final ssim_25 : %f, final ssim max_25: %f' % (psnr_2_25, psnr_2_25_max, final_ssim_25, final_ssim_max_25)) i += 1 return total_loss
print image_name1.shape print image_name2.shape #estimate the standard deiviation of the images std_1 = numpy.std (numpy.std (numpy.array(image_name1))) std_2 = numpy.std (numpy.std (numpy.array(image_name2))) print ("std is %2.10f"%std_1) #print ("Standard deviation of the images are"%(std_1,std_2)) #estimate the peak signal to noise ratio (PSNR) between the image peak_signal_to_noise_ratio = measure.compare_psnr (image_name1,image_name2) print ("Peak signal to noise ratio is %s"%peak_signal_to_noise_ratio) # estimate the mean square error between the images mse = measure.compare_mse(image_name1,image_name2) print ("Mean square error between the images is %s"%mse) # estimate the normalised root mean square error between the images rmse = measure.compare_nrmse(image_name1,image_name2) ssim = measure.compare_ssim(image_name1,image_name2) print ("Normalised root mean squre error between the images is %s"%rmse)
def psnr(img,gt): return compare_psnr(gt,img)
output = np.minimum(np.maximum(output, 0), 1) # print('**output shape', sess.run(tf.shape(output))) g_loss[ind] = G_current # if cnt % 20 == 0: train_writer.add_summary(summary, cnt) print( "%d %d Loss=%.3f Time=%.3f" % (epoch, cnt, np.mean(g_loss[np.where(g_loss)]), time.time() - st)) if epoch % save_freq == 0: if not os.path.isdir(result_dir + '%04d' % epoch): os.makedirs(result_dir + '%04d' % epoch) psnr = compare_psnr(output[0, :, :, :], gt_patch[0, :, :, :], data_range=1.0) ssim = compare_ssim(output[0, :, :, :], gt_patch[0, :, :, :], multichannel=True) with open(os.path.join(log_dir, 'val.txt'), 'a+') as f: f.write('epoch: ' + str(epoch) + ' id: ' + str(train_id) + ' psnr: ' + str(psnr) + 'ssim: ' + str(ssim) + '\n') temp = np.concatenate((gt_patch[0, :, :, :], output[0, :, :, :]), axis=1) # PIL.Image.fromarray((temp * 255).astype('uint8')).convert('RGB').save( # result_dir + '%04d/%05d_00_train_%d_pil.jpg' % (epoch, train_id, ratio)) scipy.misc.toimage(temp * 255, high=255, low=0, cmin=0, cmax=255).save(result_dir + '%04d/%s_00_train.jpg' %
def test_PSNR_float(): p_uint8 = compare_psnr(cam, cam_noisy) p_float64 = compare_psnr(cam/255., cam_noisy/255., data_range=1) assert_almost_equal(p_uint8, p_float64, decimal=5)
def test_cycle_spinning_multichannel(): sigma = 0.1 rstate = np.random.RandomState(1234) for multichannel in True, False: if multichannel: img = astro # can either omit or be 0 along the channels axis valid_shifts = [1, (0, 1), (1, 0), (1, 1), (1, 1, 0)] # can either omit or be 1 on channels axis. valid_steps = [1, 2, (1, 2), (1, 2, 1)] # too few or too many shifts or non-zero shift on channels invalid_shifts = [(1, 1, 2), (1, ), (1, 1, 0, 1)] # too few or too many shifts or any shifts <= 0 invalid_steps = [(1, ), (1, 1, 1, 1), (0, 1), (-1, -1)] else: img = astro_gray valid_shifts = [1, (0, 1), (1, 0), (1, 1)] valid_steps = [1, 2, (1, 2)] invalid_shifts = [(1, 1, 2), (1, )] invalid_steps = [(1, ), (1, 1, 1), (0, 1), (-1, -1)] noisy = img.copy() + 0.1 * rstate.randn(*(img.shape)) denoise_func = restoration.denoise_wavelet func_kw = dict(sigma=sigma, multichannel=multichannel) # max_shifts=0 is equivalent to just calling denoise_func with expected_warnings([PYWAVELET_ND_INDEXING_WARNING, DASK_NOT_INSTALLED_WARNING]): dn_cc = restoration.cycle_spin(noisy, denoise_func, max_shifts=0, func_kw=func_kw, multichannel=multichannel) dn = denoise_func(noisy, **func_kw) assert_equal(dn, dn_cc) # denoising with cycle spinning will give better PSNR than without for max_shifts in valid_shifts: with expected_warnings([PYWAVELET_ND_INDEXING_WARNING, DASK_NOT_INSTALLED_WARNING]): dn_cc = restoration.cycle_spin(noisy, denoise_func, max_shifts=max_shifts, func_kw=func_kw, multichannel=multichannel) assert_(compare_psnr(img, dn_cc) > compare_psnr(img, dn)) for shift_steps in valid_steps: with expected_warnings([PYWAVELET_ND_INDEXING_WARNING, DASK_NOT_INSTALLED_WARNING]): dn_cc = restoration.cycle_spin(noisy, denoise_func, max_shifts=2, shift_steps=shift_steps, func_kw=func_kw, multichannel=multichannel) assert_(compare_psnr(img, dn_cc) > compare_psnr(img, dn)) for max_shifts in invalid_shifts: with testing.raises(ValueError): dn_cc = restoration.cycle_spin(noisy, denoise_func, max_shifts=max_shifts, func_kw=func_kw, multichannel=multichannel) for shift_steps in invalid_steps: with testing.raises(ValueError): dn_cc = restoration.cycle_spin(noisy, denoise_func, max_shifts=2, shift_steps=shift_steps, func_kw=func_kw, multichannel=multichannel)
if len(sys.argv) > 1: model_location = str(sys.argv[1]) if len(sys.argv) > 2: img_location = str(sys.argv[2]) print('Inference on {} using model {}'.format(img_location, model_location)) model = load_model( model_location, custom_objects={ 'tf':tf, 'find_medians': find_medians, 'merge': merge }) src_img = cv2.imread(img_location) img = np.asarray(src_img / 255.0, np.float) noisy_img = skimage.util.random_noise(img, mode='s&p', amount=0.7) gx0 = np.reshape(noisy_img, (1, *noisy_img.shape)) Y = model.predict(gx0, verbose=1) result = np.asarray(Y[0,:,:,:], np.float) cv2.imshow('original', src_img) cv2.imshow('bef', noisy_img) cv2.imshow('aft', result) print('psnr original', compare_psnr(img, noisy_img)) print('psnr smoothed', compare_psnr(img, result)) cv2.waitKey(0)
def test_wavelet_denoising(): rstate = np.random.RandomState(1234) # version with one odd-sized dimension astro_gray_odd = astro_gray[:, :-1] astro_odd = astro[:, :-1] for img, multichannel in [(astro_gray, False), (astro_gray_odd, False), (astro_odd, True)]: sigma = 0.1 noisy = img + sigma * rstate.randn(*(img.shape)) noisy = np.clip(noisy, 0, 1) # Verify that SNR is improved when true sigma is used denoised = restoration.denoise_wavelet(noisy, sigma=sigma, multichannel=multichannel) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy) # Verify that SNR is improved with internally estimated sigma denoised = restoration.denoise_wavelet(noisy, multichannel=multichannel) psnr_noisy = compare_psnr(img, noisy) psnr_denoised = compare_psnr(img, denoised) assert_(psnr_denoised > psnr_noisy) # Test changing noise_std (higher threshold, so less energy in signal) res1 = restoration.denoise_wavelet(noisy, sigma=2*sigma, multichannel=multichannel) res2 = restoration.denoise_wavelet(noisy, sigma=sigma, multichannel=multichannel) assert_(np.sum(res1**2) <= np.sum(res2**2))