def test_NRMSE_no_int_overflow(): camf = cam.astype(np.float32) cam_noisyf = cam_noisy.astype(np.float32) assert_almost_equal(mean_squared_error(cam, cam_noisy), mean_squared_error(camf, cam_noisyf)) assert_almost_equal(normalized_root_mse(cam, cam_noisy), normalized_root_mse(camf, cam_noisyf))
def test_NRMSE_errors(): x = np.ones(4) # shape mismatch with pytest.raises(ValueError): normalized_root_mse(x[:-1], x) # invalid normalization name with pytest.raises(ValueError): normalized_root_mse(x, x, normalization='foo')
def test_NRMSE(): x = np.ones(4) y = np.asarray([0., 2., 2., 2.]) assert_equal(normalized_root_mse(y, x, 'mean'), 1 / np.mean(y)) assert_equal(normalized_root_mse(y, x, 'Euclidean'), 1 / np.sqrt(3)) assert_equal(normalized_root_mse(y, x, 'min-max'), 1 / (y.max() - y.min())) # mixed precision inputs are allowed assert_almost_equal(normalized_root_mse(y, np.float32(x), 'min-max'), 1 / (y.max() - y.min()))
def test_inpaint_nrmse(dtype, order, channel_axis, split_into_regions): image_orig = data.astronaut()[:, :200] float_dtype = np.float32 if dtype == np.float32 else np.float64 image_orig = image_orig.astype(float_dtype, copy=False) # Create mask with six block defect regions mask = np.zeros(image_orig.shape[:-1], dtype=bool) mask[20:50, 3:20] = 1 mask[165:180, 90:155] = 1 mask[40:60, 170:195] = 1 mask[-60:-40, 170:195] = 1 mask[-180:-165, 90:155] = 1 mask[-50:-20, :20] = 1 # add a few long, narrow defects mask[200:205, -200:] = 1 mask[150:255, 20:22] = 1 mask[365:368, 60:130] = 1 # add randomly positioned small point-like defects rstate = np.random.default_rng(0) for radius in [0, 2, 4]: # larger defects are less common thresh = 3.25 + 0.25 * radius # larger defects less commmon tmp_mask = rstate.standard_normal(image_orig.shape[:-1]) > thresh if radius > 0: tmp_mask = binary_dilation(tmp_mask, disk(radius, dtype=bool)) mask[tmp_mask] = 1 # Defect image over the same region in each color channel image_defect = image_orig.copy() for layer in range(image_defect.shape[-1]): image_defect[np.where(mask)] = 0 if channel_axis is None: image_orig = rgb2gray(image_orig) image_defect = rgb2gray(image_defect) image_orig = image_orig.astype(dtype, copy=False) image_defect = image_defect.astype(dtype, copy=False) image_defect = np.asarray(image_defect, order=order) image_result = inpaint.inpaint_biharmonic( image_defect, mask, channel_axis=channel_axis, split_into_regions=split_into_regions) assert image_result.dtype == float_dtype nrmse_defect = normalized_root_mse(image_orig, image_defect) nrmse_result = normalized_root_mse(img_as_float(image_orig), image_result) assert nrmse_result < 0.2 * nrmse_defect
def plot_planet_results(mask, T1, T1est, T2, T2est, df, dfest): nx, ny = 3, 3 plt.subplot(nx, ny, 1) plt.imshow(T1*mask) plt.title('T1 Truth') plt.axis('off') plt.subplot(nx, ny, 2) plt.imshow(T1est) plt.title('T1 est') plt.axis('off') plt.subplot(nx, ny, 3) plt.imshow(T1*mask - T1est) plt.title('NRMSE: %g' % normalized_root_mse(T1, T1est)) plt.axis('off') plt.subplot(nx, ny, 4) plt.imshow(T2*mask) plt.title('T2 Truth') plt.axis('off') plt.subplot(nx, ny, 5) plt.imshow(T2est) plt.title('T2 est') plt.axis('off') plt.subplot(nx, ny, 6) plt.imshow(T2*mask - T2est) plt.title('NRMSE: %g' % normalized_root_mse(T2, T2est)) plt.axis('off') plt.subplot(nx, ny, 7) plt.imshow(df*mask) plt.title('df Truth') plt.axis('off') plt.subplot(nx, ny, 8) plt.imshow(dfest) plt.title('df est') plt.axis('off') plt.subplot(nx, ny, 9) plt.imshow(df*mask - dfest) plt.title('NRMSE: %g' % normalized_root_mse(df*mask, dfest)) plt.axis('off') plt.show()
def test_NRMSE(dtype): x = np.ones(4, dtype=dtype) y = np.asarray([0., 2., 2., 2.], dtype=dtype) nrmse = normalized_root_mse(y, x, normalization='mean') assert nrmse.dtype == np.float64 assert_equal(nrmse, 1 / np.mean(y)) assert_equal(normalized_root_mse(y, x, normalization='euclidean'), 1 / np.sqrt(3)) assert_equal(normalized_root_mse(y, x, normalization='min-max'), 1 / (y.max() - y.min())) # mixed precision inputs are allowed assert_almost_equal( normalized_root_mse(y, np.float32(x), normalization='min-max'), 1 / (y.max() - y.min()))
def __call__(img1, img2, tensor=True): if tensor: img1 = convert_tensor_to_nparray(img1) img2 = convert_tensor_to_nparray(img2) img1 = remove_outliers_eval(img1) img2 = remove_outliers_eval(img2) return normalized_root_mse(img1, img2)
def test(args, test_loader, model, device): model.eval() test_loss = 0 rmse = 0 psnr = 0 ssim = 0 with torch.no_grad(): for hr, lr, target in test_loader: lr, hr, target = lr.to(device), hr.to(device), target.to(device) output = model(hr, lr) test_loss_function = nn.L1Loss(reduction='sum') test_loss = test_loss_function(output, target).item() real = np.moveaxis(target.numpy(), 1, 3) predicted = np.moveaxis(output.numpy(), 1, 3) rmse += skm.normalized_root_mse(real, predicted) psnr += skm.peak_signal_noise_ratio(real, predicted, data_range=real.max() - real.min()) for i in range(5): ssim += skm.structural_similarity(real[i], predicted[i], multichannel=True, data_range=real.max() - real.min()) test_loss /= len(test_loader.dataset) rmse /= len(test_loader.dataset) psnr /= len(test_loader.dataset) ssim /= len(test_loader.dataset) print( '\nTest set: Average values --> Loss: {:.4f}, RMSE: ({:.2f}), PSNR: ({:.2f}dB),' ' SSIM: ({:.2f})\n'.format(test_loss, rmse, psnr, ssim))
def test_image_align_precise(self, precise, instance, image_ref, image_translated): tolerance = 0.1 if precise else 0.12 result = instance.align(image_translated, precise=precise) assert result.shape == image_ref.shape assert round(normalized_root_mse(image_ref, result), 5) < tolerance
def evaluate(individual: List[float], ref_img: np.ndarray) -> Tuple[float]: im_shape = ref_img.shape gen_img = express_genome_to_image(np.array(individual), im_shape) gen_array = np.array(gen_img) gen_array[:, :, 3] = 255 error = normalized_root_mse(ref_img, gen_array) return error.item(),
def planet_phantom_example(): TR, alpha = 24e-3, np.deg2rad(70) sig, df = load_data() coil_index = 0 sig = sig[:, :, coil_index, :] df = df[:, :, coil_index] sig = sig.transpose((2, 0, 1)) # Move pc to 0 index sig = sig[..., None] # Do T1, T2 mapping for each pixel mask = np.abs(sig[1, :, :, :]) > 5e-8 print('-------') print(sig.shape) print(df.shape) print(mask.shape) # Do the thing t0 = perf_counter() Mmap, T1est, T2est, dfest = planet(sig, alpha, TR, pc_axis=0) print('Took %g sec to run PLANET' % (perf_counter() - t0)) print(sig.shape) print(df.shape) print(dfest.shape) # Simple phase unwrapping of off-resonance estimate dfest = unwrap_phase(dfest * 2 * np.pi * TR) / (2 * np.pi * TR) nx, ny = 3, 3 plt.subplot(nx, ny, 2) plt.imshow(T1est) plt.title('T1 est') plt.axis('off') plt.subplot(nx, ny, 5) plt.imshow(T2est) plt.title('T2 est') plt.axis('off') plt.subplot(nx, ny, 7) plt.imshow(np.abs(df)) plt.title('df Truth') plt.axis('off') plt.subplot(nx, ny, 8) plt.imshow(np.abs(dfest)) plt.title('df est') plt.axis('off') plt.subplot(nx, ny, 9) plt.imshow(np.abs(df - dfest[:, :, 0])) plt.title('NRMSE: %g' % normalized_root_mse(df, dfest[:, :, 0])) plt.axis('off') plt.show()
def compare_imgs(im1, im2, fil_out): with warnings.catch_warnings(): warnings.simplefilter( "ignore") # ignore skimage's deprecation warinings. # structural similarity index # [ss, im] = metrics.structural_similarity(im1,im2,multichannel=True) [ss, im] = metrics.structural_similarity(im1, im2, gaussian_weights=True, sigma=1.5, use_sample_covariance=False, multichannel=True, full=True) if fil_out: im8 = skimage.img_as_ubyte(np.clip(im, -1.0, 1.0)) save_img(fil_out, im8) # mean square error mse = metrics.mean_squared_error(im1, im2) # normalized root mean squared error nrmse = metrics.normalized_root_mse(im1, im2) # peak signal-to-noise ratio psnr = metrics.peak_signal_noise_ratio(im1, im2) return [ss, mse, nrmse, psnr]
def compute_metrics(seriesX, seriesY, metric, window): # Smooth the data if needed if window != 'none': seriesX = smooth(x=seriesX, window_len=5, window=window) seriesY = smooth(x=seriesY, window_len=5, window=window) if seriesX.shape != seriesY.shape: raise ValueError('Only accepts signals that have the same shape.') # Compute the similarity metrics if metric == 'zncc': return getZNCC(seriesX, seriesY) if metric == 'ssim': return ski_metrics.structural_similarity(seriesX, seriesY) if metric == 'psnr': return getPSNR(seriesX, seriesY) if metric == 'f-test': return stats.f_oneway(seriesX, seriesY)[0] seriesX, seriesY = pd.Series(seriesX), pd.Series(seriesY) if metric == 'pearsonr': return seriesX.corr(seriesY, method='pearson') if metric == 'spearmanr': return seriesX.corr(seriesY, method='spearman') if metric == 'kendalltau': return seriesX.corr(seriesY, method='kendall') # Compute dissimilarity metrics if metric == 'mse': return ski_metrics.mean_squared_error(seriesX, seriesY) if metric == 'nrmse': return ski_metrics.normalized_root_mse(seriesX, seriesY) if metric == 'me': return getME(seriesX, seriesY) if metric == 'mae': return getMAE(seriesX, seriesY) if metric == 'msle': return getMSLE(seriesX, seriesY) if metric == 'medae': return getMedAE(seriesX, seriesY)
def compute_metrics(df1, df2, metrics, window): number_of_columns1 = len(df1.columns) number_of_columns2 = len(df2.columns) # { var1_names, var2_names, metric1: 2d array, metric2: ... }} result = { 'var1_names': df1.columns[1:].tolist(), 'var2_names': df2.columns[1:].tolist() } for m in metrics: result[m] = np.zeros((number_of_columns1 - 1, number_of_columns2 - 1)) # Using nested for loops to create a 2-D matrix for i in range(number_of_columns1 - 1): for j in range(number_of_columns2 - 1): X = df1.columns[i + 1] Y = df2.columns[j + 1] # Remove missing data if needed seriesX = removeMissingData(df1[X]) seriesY = removeMissingData(df2[Y]) # Smooth the data if needed if window != 'none': seriesX = smooth(x=seriesX, window_len=5, window=window) seriesY = smooth(x=seriesY, window_len=5, window=window) if seriesX.shape != seriesY.shape: raise ValueError('Only accepts signals that have the same shape.') # Compute the similarity metrics if 'zncc' in metrics: result['zncc'][i][j] = getZNCC(seriesX, seriesY) if 'ssim' in metrics: result['ssim'][i][j] = ski_metrics.structural_similarity(seriesX, seriesY) if 'psnr' in metrics: result['psnr'][i][j] = getPSNR(seriesX, seriesY) # Note: added by Phong if 'f-test' in metrics: result['f-test'][i][j] = stats.f_oneway(seriesX, seriesY)[0] # Use pandas corr to ingnore inf and nan. seriesX, seriesY = pd.Series(seriesX), pd.Series(seriesY) if 'pearsonr' in metrics: result['pearsonr'][i][j] = seriesX.corr(seriesY, method='pearson') if 'spearmanr' in metrics: result['spearmanr'][i][j] = seriesX.corr(seriesY, method='spearman') if 'kendalltau' in metrics: result['kendalltau'][i][j] = seriesX.corr(seriesY, method='kendall') # Compute dissimilarity metrics if 'mse' in metrics: result['mse'][i][j] = ski_metrics.mean_squared_error(seriesX, seriesY) if 'nrmse' in metrics: result['nrmse'][i][j] = ski_metrics.normalized_root_mse(seriesX, seriesY) if 'me' in metrics: result['me'][i][j] = getME(seriesX, seriesY) if 'mae' in metrics: result['mae'][i][j] = getMAE(seriesX, seriesY) if 'msle' in metrics: result['msle'][i][j] = getMSLE(seriesX, seriesY) if 'medae' in metrics: result['medae'][i][j] = getMedAE(seriesX, seriesY) # Note: added by Phong # Replace NaN with 0 for serialisation for m in metrics: result[m] = np.nan_to_num(result[m]) return result
def parallel_comparison(args): orig_path, comp_path = args orig_img = io.imread(orig_path) comp_img = io.imread(comp_path) comparisons = [] comparisons.append( metrics.structural_similarity(orig_img, comp_img, multichannel=True)) comparisons.append(metrics.peak_signal_noise_ratio(orig_img, comp_img)) comparisons.append(metrics.mean_squared_error(orig_img, comp_img)) comparisons.append(metrics.normalized_root_mse(orig_img, comp_img)) return comparisons
def calc_metircs(gt, out, tag): ssim, ssimMAP = structural_similarity(gt, out, data_range=1, full=True) nrmse = normalized_root_mse(gt, out) psnr = peak_signal_noise_ratio(gt, out, data_range=1) uqi = UQICalc(gt, out) metrics = { "SSIM" + tag: ssim, "NRMSE" + tag: nrmse, "PSNR" + tag: psnr, "UQI" + tag: uqi } return metrics, ssimMAP
def metrics_example(dataframe, noise_class_list): """Show metrics example Arguments: dataframe {Dataframe} -- Dataframe that contains images path noise_class_list {List} -- List of noise type Returns: Dataframe -- Dataframe that contain metrics example """ path = dataframe.iloc[0, 0] orignal_img = cv2.imread(path, cv2.IMREAD_GRAYSCALE) orignal_img = np.array(orignal_img, np.float32) images = [orignal_img] df_error = pd.DataFrame({ "Noise": [], "MSE": [], "NRMSE": [], "PSNR": [], "SSIM": [] }) for noise in noise_class_list: noised_img = noise.add(orignal_img) images.append(noised_img) noise_name = noise.__class__.__name__ mse = metrics.mean_squared_error(orignal_img, noised_img) nrmse = metrics.normalized_root_mse(orignal_img, noised_img) psnr = metrics.peak_signal_noise_ratio(orignal_img, noised_img, data_range=255) ssim = metrics.structural_similarity(orignal_img, noised_img) df_error = df_error.append( { "Noise": noise_name, "MSE": mse, "NRMSE": nrmse, "PSNR": psnr, "SSIM": ssim }, ignore_index=True) plot_im_grid_from_list(images, 5, 2) df_error.head(len(noise_class_list)) return df_error
def calc_metircs(gt, out, tag, norm4diff=False): ssim, ssimMAP = structural_similarity(gt, out, data_range=1, full=True) nrmse = normalized_root_mse(gt, out) psnr = peak_signal_noise_ratio(gt, out, data_range=1) uqi = UQICalc(gt, out) if norm4diff: gt = minmax(gt) out = minmax(out) diff = gt - out dif_std = np.std(diff) metrics = { "SSIM"+tag: ssim, "NRMSE"+tag: nrmse, "PSNR"+tag: psnr, "UQI"+tag: uqi, "SDofDiff"+tag: dif_std } return metrics, ssimMAP, abs(diff)
def compare_images(original_img, transformed_img): """Compares original image to transformed image Arguments: orignal_img {Array} -- Numpy like array of image [Non-normalize (0-255)] transformed_img {Array} -- Numpy like array of image [Non-normalize (0-255)] Returns: dict -- {"MSE", "NRMSE", "PSNR", "SSIM"} """ original_img = np.array(original_img, np.float32) transformed_img = np.array(transformed_img, np.float32) mse = metrics.mean_squared_error(original_img, transformed_img) nrmse = metrics.normalized_root_mse(original_img, transformed_img) ssim = metrics.structural_similarity(original_img, transformed_img) psnr = metrics.peak_signal_noise_ratio(original_img, transformed_img, data_range=255) return {"MSE": mse, "NRMSE": nrmse, "PSNR": psnr, "SSIM": ssim}
def skimage_metrics(self, im1, im2): ## Metric 1: MSE (Mean Squared Error) mse = compare.mean_squared_error(im1, im2) ## Metric 1.1: NRMSE (Normalized Root Mean Squared Error) nrmse = compare.normalized_root_mse(im1, im2, normalization='euclidean') ## Metric 2: SSIM (Structural Similarity Image Matrix) ssim = compare.structural_similarity(im1, im2, data_range=im2.max() - im2.min()) ## Metric 3: Peak Signal-to-Noise ratio if mse > 0: psnr = compare.peak_signal_noise_ratio(im1, im2, data_range=im2.max() - im2.min()) else: psnr = -1 return mse, nrmse, ssim, psnr
def test(args, test_loader, model, device, epoch): model.eval() test_loss = 0 rmse = 0 psnr = 0 ssim = 0 with torch.no_grad(): for hr, lr, target in test_loader: hr_crop, lr_crop, target_crop = crop(hr, lr, target, 128, 64, 128) lr_crop, hr_crop, target_crop = lr_crop.to(device), hr_crop.to( device), target_crop.to(device) output = model(hr_crop, lr_crop) test_loss_function = nn.L1Loss(reduction='sum') test_loss = test_loss_function(output, target_crop).item() real = np.moveaxis(target_crop.cpu().numpy(), 1, 3) predicted = np.moveaxis(output.cpu().numpy(), 1, 3) for i in range(args.test_batch_size): rmse += skm.normalized_root_mse(real[i], predicted[i]) psnr += skm.peak_signal_noise_ratio(real[i], predicted[i], data_range=real.max() - real.min()) ssim += skm.structural_similarity(real[i], predicted[i], multichannel=True, data_range=real.max() - real.min()) # tb.add_scalar("Loss/test", test_loss, epoch) # tb.add_scalar("RMSE/test", rmse/5, epoch) # tb.add_scalar("PSNR/test", psnr/5, epoch) # tb.add_scalar("SSIM/test", ssim/5, epoch) test_loss /= len(test_loader.dataset) rmse /= len(test_loader.dataset) psnr /= len(test_loader.dataset) ssim /= len(test_loader.dataset) print( '\nTest set: Average values --> Loss: {:.4f}, RMSE: ({:.2f}), PSNR: ({:.2f}dB),' ' SSIM: ({:.2f})\n'.format(test_loss, rmse, psnr, ssim))
def validation(args, val_loader, model, device): model.eval() val_loss = 0 rmse = 0 psnr = 0 ssim = 0 with torch.no_grad(): for hr, lr, target in val_loader: hr_crop, lr_crop, target_crop = crop(hr, lr, target, 128, 64, 128) lr_crop, hr_crop, target_crop = lr_crop.to(device), hr_crop.to( device), target_crop.to(device) output = model(hr_crop, lr_crop) val_loss_function = nn.L1Loss(reduction='sum') val_loss = val_loss_function(output, target_crop).item() real = np.moveaxis(target_crop.cpu().numpy(), 1, 3) predicted = np.moveaxis(output.cpu().numpy(), 1, 3) for i in range(args.test_batch_size): rmse += skm.normalized_root_mse(real[i], predicted[i]) psnr += skm.peak_signal_noise_ratio(real[i], predicted[i], data_range=real.max() - real.min()) ssim += skm.structural_similarity(real[i], predicted[i], multichannel=True, data_range=real.max() - real.min()) val_loss /= len(val_loader.dataset) rmse /= len(val_loader.dataset) psnr /= len(val_loader.dataset) ssim /= len(val_loader.dataset) print( '\nValidation set: Average values --> Loss: {:.4f}, RMSE: ({:.2f}), PSNR: ({:.2f}dB),' ' SSIM: ({:.2f})\n'.format(val_loss, rmse, psnr, ssim)) np.save('val_input.npy', (np.moveaxis(lr_crop.cpu().numpy(), 1, 3))) np.save('val_real.npy', real) np.save('val_output.npy', predicted)
def __call__(self, input, target): input, target = convert_to_numpy(input, target) return normalized_root_mse(target, input)
grayA = cv2.imread(fst_file, 0) grayB = cv2.imread(snd_file, 0) grayBG = cv2.imread(bg_file, 0) # Remove background and threshold to remove shadow effects threshold = 20 diffA = cv2.absdiff(grayA, grayBG) thresA = cv2.threshold(diffA, threshold, 255, cv2.THRESH_BINARY)[1] diffB = cv2.absdiff(grayB, grayBG) thresB = cv2.threshold(diffB, threshold, 255, cv2.THRESH_BINARY)[1] # compute the Normalised Root Mean-Squared Error (NRMSE) between the two # images score = normalized_root_mse(thresA, thresB) # Compare the current image with the image from 5 layers ago # This is used to check for filament runout or huge deviance deviance = 1.0 scr_diff = 0.0 dev_diff = 0.0 if curr > 5: trd_file = fst_file[:-10] + str(curr - 5).rjust(6, '0') + fst_file[-4:] #imageC = cv2.imread(trd_file) grayC = cv2.imread(trd_file, 0) diffC = cv2.absdiff(grayC, grayBG) thresC = cv2.threshold(diffC, threshold, 255, cv2.THRESH_BINARY)[1] deviance = normalized_root_mse(thresA, thresC) # Calculate difference compared with previous layer score and deviance
Ip8_hi += sigma * (np.random.normal(0, 1, Ip8_hi.shape) + 1j * np.random.normal(0, 1, Ip8_hi.shape)) Ip6_lo += sigma * (np.random.normal(0, 1, Ip6_lo.shape) + 1j * np.random.normal(0, 1, Ip6_lo.shape)) Ip8_lo += sigma * (np.random.normal(0, 1, Ip8_lo.shape) + 1j * np.random.normal(0, 1, Ip8_lo.shape)) # Do the thing if fimtre_results: theta6_hi = fimtre(I0_hi, I1_6_hi, TR0, TR1, rad=False) * mask theta8_hi = fimtre(I0_hi, I1_8_hi, TR0, TR1, rad=False) * mask theta6_lo = fimtre(I0_lo, I1_6_lo, TR0, TR1, rad=False) * mask theta8_lo = fimtre(I0_lo, I1_8_lo, TR0, TR1, rad=False) * mask # reverse polarity if it makes sense if normalized_root_mse(theta6_hi, df) > normalized_root_mse( -1 * theta6_hi, df): theta6_hi *= -1 if normalized_root_mse(theta8_hi, df) > normalized_root_mse( -1 * theta8_hi, df): theta8_hi *= -1 if normalized_root_mse(theta6_lo, df) > normalized_root_mse( -1 * theta6_lo, df): theta6_lo *= -1 if normalized_root_mse(theta8_lo, df) > normalized_root_mse( -1 * theta8_lo, df): theta8_lo *= -1 if planet_results: _Meff, _T1, _T2, theta_planet6_hi = planet( Ip6_hi, TR=TR0, alpha=alpha, pc_axis=-1) * mask
def planet_shepp_logan_example(): # Shepp-Logan N, nslices, npcs = 128, 1, 8 # 2 slices just to show we can M0, T1, T2 = shepp_logan((N, N, nslices), MR=True, zlims=(-.25, 0)) # Simulate bSSFP acquisition with linear off-resonance TR, alpha = 3e-3, np.deg2rad(15) pcs = np.linspace(0, 2 * np.pi, npcs, endpoint=False) df, _ = np.meshgrid(np.linspace(-1 / TR, 1 / TR, N), np.linspace(-1 / TR, 1 / TR, N)) sig = np.empty((npcs, ) + T1.shape, dtype='complex') for sl in range(nslices): sig[..., sl] = bssfp(T1[..., sl], T2[..., sl], TR, alpha, field_map=df, phase_cyc=pcs, M0=M0[..., sl]) # Do T1, T2 mapping for each pixel mask = np.abs(M0) > 1e-8 # Make it noisy np.random.seed(0) sig += 1e-5 * (np.random.normal(0, 1, sig.shape) + 1j * np.random.normal(0, 1, sig.shape)) * mask print(sig.shape, alpha, TR, mask.shape) # Show the phase-cycled images nx, ny = 2, 4 plt.figure() for ii in range(nx * ny): plt.subplot(nx, ny, ii + 1) plt.imshow(np.abs(sig[ii, :, :, 0])) plt.title('%d deg PC' % (ii * (360 / npcs))) plt.show() # Do the thing t0 = perf_counter() Mmap, T1est, T2est, dfest = planet(sig, alpha, TR, mask=mask, pc_axis=0) print('Took %g sec to run PLANET' % (perf_counter() - t0)) print(T1est.shape, T2est.shape, dfest.shape, T1.shape, T2.shape, mask.shape) # Look at a single slice sl = 0 T1est = T1est[..., sl] T2est = T2est[..., sl] dfest = dfest[..., sl] T1 = T1[..., sl] T2 = T2[..., sl] mask = mask[..., sl] # Simple phase unwrapping of off-resonance estimate dfest = unwrap_phase(dfest * 2 * np.pi * TR) / (2 * np.pi * TR) print('t1, mask:', T1.shape, mask.shape) nx, ny = 3, 3 plt.subplot(nx, ny, 1) plt.imshow(T1 * mask) plt.title('T1 Truth') plt.axis('off') plt.subplot(nx, ny, 2) plt.imshow(T1est) plt.title('T1 est') plt.axis('off') plt.subplot(nx, ny, 3) plt.imshow(T1 * mask - T1est) plt.title('NRMSE: %g' % normalized_root_mse(T1, T1est)) plt.axis('off') plt.subplot(nx, ny, 4) plt.imshow(T2 * mask) plt.title('T2 Truth') plt.axis('off') plt.subplot(nx, ny, 5) plt.imshow(T2est) plt.title('T2 est') plt.axis('off') plt.subplot(nx, ny, 6) plt.imshow(T2 * mask - T2est) plt.title('NRMSE: %g' % normalized_root_mse(T2, T2est)) plt.axis('off') plt.subplot(nx, ny, 7) plt.imshow(df * mask) plt.title('df Truth') plt.axis('off') plt.subplot(nx, ny, 8) plt.imshow(dfest) plt.title('df est') plt.axis('off') plt.subplot(nx, ny, 9) plt.imshow(df * mask - dfest) plt.title('NRMSE: %g' % normalized_root_mse(df * mask, dfest)) plt.axis('off') plt.show()
def normalized_rmse(img_a, img_b): return sk_metrics.normalized_root_mse(img_a, img_b)
def brain_planet_virtual_ellipse_example(): N = 128 filepath = './data' data = load_dataslice(filepath, image_index=1, slice_index=150) freq = 1 / 3e-3 offres = generate_offres(N, f=freq, rotate=True, deform=True) # alpha = flip angle alpha = np.deg2rad(100) #Create brain phantom phantom = generate_phantom(data, alpha, offres=offres) #Get phantom parameter M0, T1, T2, _alpha, df, _sample = get_phantom_parameters(phantom) # Generate phase-cycled images TR = 3e-3 TE = TR / 2 pcs = np.linspace(0, 2 * np.pi, 4, endpoint=False) M = ma_ssfp(T1, T2, TR, TE, alpha, f0=-df, dphi=pcs, M0=M0) #M = add_noise_gaussian(M, sigma=0.0) M = np.transpose(M, (2, 0, 1)) M = M[..., None] TR1 = 3.45e-3 TE1 = TR / 2 pcs = np.linspace(0, 2 * np.pi, 4, endpoint=False) M1 = ma_ssfp(T1, T2, TR1, TE1, alpha, f0=-df, dphi=pcs, M0=M0) M1 = np.transpose(M1, (2, 0, 1)) M1 = M1[..., None] # Do T1, T2 mapping for each pixel mask = np.abs(M0) > 1e-8 mask = mask[..., None] print(M.shape, alpha, TR, mask.shape) # Look at a single slice sl = 0 mask = mask[..., sl] print(M.shape, M1.shape, M.shape[-1], M1.shape[-1]) phi = ormtre(M, M1, mask, TR, TR1, pc_axis=0, rad=True) plt.figure() plt.imshow(phi) plt.show() print('M, phi', M.shape, phi[..., None].shape) v = np.empty(M.shape, dtype=M.dtype) v[..., :4] = M v[..., 4:] = M1 * np.exp(1j * phi[None, ...]) print('v', v.shape) t0 = perf_counter() Mmap, T1est, T2est, dfest = planet(v, alpha=alpha, TR=(TR + TR1) / 2, mask=mask, pc_axis=0) print('Took %g sec to run PLANET' % (perf_counter() - t0)) # Look at a single slice sl = 0 T1est = T1est[..., sl] T2est = T2est[..., sl] dfest = dfest[..., sl] #T1 = T1[..., sl] #T2 = T2[..., sl] mask = mask[..., sl] # Simple phase unwrapping of off-resonance estimate dfest = unwrap_phase(dfest * 2 * np.pi * TR) / (2 * np.pi * TR) print('t1, mask:', T1.shape, mask.shape) nx, ny = 3, 3 plt.subplot(nx, ny, 1) plt.imshow(T1 * mask) plt.title('T1 Truth') plt.axis('off') plt.subplot(nx, ny, 2) plt.imshow(T1est) plt.title('T1 est') plt.axis('off') plt.subplot(nx, ny, 3) plt.imshow(T1 * mask - T1est) plt.title('NRMSE: %g' % normalized_root_mse(T1, T1est)) plt.axis('off') plt.subplot(nx, ny, 4) plt.imshow(T2 * mask) plt.title('T2 Truth') plt.axis('off') plt.subplot(nx, ny, 5) plt.imshow(T2est) plt.title('T2 est') plt.axis('off') plt.subplot(nx, ny, 6) plt.imshow(T2 * mask - T2est) plt.title('NRMSE: %g' % normalized_root_mse(T2, T2est)) plt.axis('off') plt.subplot(nx, ny, 7) plt.imshow(df * mask) plt.title('df Truth') plt.axis('off') plt.subplot(nx, ny, 8) plt.imshow(dfest) plt.title('df est') plt.axis('off') plt.subplot(nx, ny, 9) plt.imshow(df * mask - dfest) plt.title('NRMSE: %g' % normalized_root_mse(df * mask, dfest)) plt.axis('off') plt.show()
def evaluation(model_name, weights, data_loader, use_cuda=False): ''' Evaluate a model. Parameters ---------- model_name : str Name of the model to be evaluated. weights : str Path to weights for the initialisation of the model. If None, weights are randomly initialized. data_loader : torch.utils.data.dataloader.DataLoader Data loader of the dataset. use_cuda : bool, optional Whether or not to use CUDA. The default is False. Raises ------ NameError If the model is not recognised. Returns ------- df : pandas.DataFrame Data frame with the evaluation data. ''' if model_name == "Zhang16": model = Zhang16(weights=weights) resize = transforms.Resize((256, 256)) process_output = lambda output, data: lab2rgb( torch.cat((data.cpu(), resize(z2ab(output.cpu()))), dim=1)) elif model_name == "Su20": model = Su20(weights=weights) resize = transforms.Resize((256, 256)) process_output = lambda output, data: lab2rgb( torch.cat((data.cpu(), resize(z2ab(output.cpu()))), dim=1)) elif model_name == "Collage": model = Collage(weights=weights) process_output = lambda output, data: lab2rgb( torch.cat((data, output), dim=1).cpu()) else: raise NameError(model_name) if use_cuda: print("Using GPU.") model.cuda() else: print("Using CPU.") model.eval() df = pd.DataFrame(columns=['name', 'nrmse', 'ssim', 'psnr', 'lpips'], index=range(len(data_loader.dataset))) idx = 0 lpips_loss = LPIPS(net='alex') for ite, (names, (data, target)) in enumerate(tqdm(data_loader)): if use_cuda: data, target = data.cuda(), target.cuda() output = model(data) images_true = lab2rgb(torch.cat((data, target), axis=1).cpu()) images_test = process_output(output, data) lpips_values = lpips_loss(images_true * 2. - 1., images_test * 2. - 1.) for i, name in enumerate(names): image_true = images_true[i].permute(1, 2, 0).numpy() image_test = images_test[i].permute(1, 2, 0).numpy() nrmse = normalized_root_mse(image_true, image_test) ssim = structural_similarity(image_true, image_test, data_range=1., multichannel=True) psnr = peak_signal_noise_ratio(image_true, image_test, data_range=1.) df.loc[idx, 'name'] = name df.loc[idx, 'nrmse'] = nrmse df.loc[idx, 'ssim'] = ssim df.loc[idx, 'psnr'] = psnr df.loc[idx, 'lpips'] = lpips_values[i].item() idx += 1 return df
def brain_planet_example(): N = 128 npcs = 8 filepath = './data' data = load_dataslice(filepath, image_index=1, slice_index=150) freq = 1 / 3e-3 offres = generate_offres(N, f=freq, rotate=True, deform=True) # alpha = flip angle alpha = np.deg2rad(15) #Create brain phantom phantom = generate_phantom(data, alpha, offres=offres) #Get phantom parameter M0, T1, T2, _alpha, df, _sample = get_phantom_parameters(phantom) # Generate phase-cycled images TR = 3e-3 TE = TR / 2 pcs = np.linspace(0, 2 * np.pi, npcs, endpoint=False) M = ma_ssfp(T1, T2, TR, TE, alpha, f0=-df, dphi=pcs, M0=M0) #M = add_noise_gaussian(M, sigma=0.0) M = np.transpose(M, (2, 0, 1)) M = M[..., None] # Do T1, T2 mapping for each pixel mask = np.abs(M0) > 1e-8 mask = mask[..., None] print(M.shape, alpha, TR, mask.shape) # Show the phase-cycled images nx, ny = 2, 4 plt.figure() for ii in range(nx * ny): plt.subplot(nx, ny, ii + 1) plt.imshow(np.abs(M[ii, :, :, 0])) plt.title('%d deg PC' % (ii * (360 / npcs))) plt.show() # Do the thing t0 = perf_counter() Mmap, T1est, T2est, dfest = planet(M, alpha, TR, mask=mask, pc_axis=0) print('Took %g sec to run PLANET' % (perf_counter() - t0)) # Look at a single slice print(T1est.shape, T2est.shape, dfest.shape, T1.shape, T2.shape, mask.shape) sl = 0 T1est = T1est[..., sl] T2est = T2est[..., sl] dfest = dfest[..., sl] #T1 = T1[..., sl] #T2 = T2[..., sl] mask = mask[..., sl] # Simple phase unwrapping of off-resonance estimate dfest = unwrap_phase(dfest * 2 * np.pi * TR) / (2 * np.pi * TR) print('t1, mask:', T1.shape, mask.shape) nx, ny = 3, 3 plt.subplot(nx, ny, 1) plt.imshow(T1 * mask) plt.title('T1 Truth') plt.axis('off') plt.subplot(nx, ny, 2) plt.imshow(T1est) plt.title('T1 est') plt.axis('off') plt.subplot(nx, ny, 3) plt.imshow(T1 * mask - T1est) plt.title('NRMSE: %g' % normalized_root_mse(T1, T1est)) plt.axis('off') plt.subplot(nx, ny, 4) plt.imshow(T2 * mask) plt.title('T2 Truth') plt.axis('off') plt.subplot(nx, ny, 5) plt.imshow(T2est) plt.title('T2 est') plt.axis('off') plt.subplot(nx, ny, 6) plt.imshow(T2 * mask - T2est) plt.title('NRMSE: %g' % normalized_root_mse(T2, T2est)) plt.axis('off') plt.subplot(nx, ny, 7) plt.imshow(df * mask) plt.title('df Truth') plt.axis('off') plt.subplot(nx, ny, 8) plt.imshow(dfest) plt.title('df est') plt.axis('off') plt.subplot(nx, ny, 9) plt.imshow(df * mask - dfest) plt.title('NRMSE: %g' % normalized_root_mse(df * mask, dfest)) plt.axis('off') plt.show()