def msssim_l1_loss(pred, tar):
return 0.7 * msssimloss(
rotate_real(pred)[:, 0:1, ...],
rotate_real(tar)[:, 0:1, ...],
) + 0.3 * maeloss(
rotate_real(pred)[:, 0:1, ...],
rotate_real(tar)[:, 0:1, ...],
)
def evaluate_dataset(self, data, max_vols=None):
""" Evaluates performance measures per volume. """
logging = pd.DataFrame(
index=range(data.volumes),
columns=["nmse", "psnr", "ssim"],
)
num = (min(data.volumes, max_vols)
if max_vols is not None else data.volumes)
t = tqdm(range(num))
for k in t:
lo, hi = data.get_slices_in_volume(k)
pred_list, tar_list = [], []
for sl in range(lo, hi):
slice_data = data[sl]
if len(slice_data) == 3:
inp, aux, tar = slice_data
inp = inp.to(self.device).unsqueeze(0)
aux = aux.to(self.device).unsqueeze(0)
tar = tar.to(self.device).unsqueeze(0)
pred = self.forward((inp, aux))
else:
inp, tar = slice_data
inp = inp.to(self.device).unsqueeze(0)
tar = tar.to(self.device).unsqueeze(0)
pred = self.forward(inp)
# make complex signals real if necessary
if tar.shape[-3] == 2:
tar = rotate_real(tar)[..., 0:1, :, :]
if pred.shape[-3] == 2:
pred = rotate_real(pred)[..., 0:1, :, :]
tar_list.append(tar.detach().cpu())
pred_list.append(pred.detach().cpu())
tar_np = torch.cat(tar_list, dim=0).squeeze(1).numpy()
pred_np = torch.cat(pred_list, dim=0).squeeze(1).numpy()
logging.iloc[k] = {
"nmse": evaluate.nmse(tar_np, pred_np),
"psnr": evaluate.psnr(tar_np, pred_np),
"ssim": evaluate.ssim(tar_np, pred_np),
}
print(
pd.DataFrame({
"min": logging.min(),
"mean": logging.mean(),
"max": logging.max(),
}))
return logging
def __call__(self, imgs):
return tuple(
[
rotate_real(img)[..., 0:1, :, :]
if img.shape[-3] == 2
else torch.abs(img)
for img in imgs
]
)
def grid_search(x, y, rec_func, grid):
""" Grid search utility for tuning hyper-parameters. """
err_min = np.inf
grid_param = None
grid_shape = [len(val) for val in grid.values()]
err = torch.zeros(grid_shape)
err_psnr = torch.zeros(grid_shape)
err_ssim = torch.zeros(grid_shape)
for grid_val, nidx in zip(itertools.product(*grid.values()),
np.ndindex(*grid_shape)):
grid_param_cur = dict(zip(grid.keys(), grid_val))
print(
"Current grid parameters (" + str(list(nidx)) + " / " +
str(grid_shape) + "): " + str(grid_param_cur),
flush=True,
)
x_rec = rec_func(y, **grid_param_cur)
err[nidx], _ = l2_error(x_rec, x, relative=True, squared=False)
err_psnr[nidx] = psnr(
rotate_real(x_rec)[:, 0:1, ...],
rotate_real(x)[:, 0:1, ...],
data_range=rotate_real(x)[:, 0:1, ...].max(),
reduction="mean",
)
err_ssim[nidx] = ssim(
rotate_real(x_rec)[:, 0:1, ...],
rotate_real(x)[:, 0:1, ...],
data_range=rotate_real(x)[:, 0:1, ...].max(),
size_average=True,
)
print("Rel. recovery error: {:1.2e}".format(err[nidx]), flush=True)
print("PSNR: {:.2f}".format(err_psnr[nidx]), flush=True)
print("SSIM: {:.2f}".format(err_ssim[nidx]), flush=True)
if err[nidx] < err_min:
grid_param = grid_param_cur
err_min = err[nidx]
return grid_param, err_min, err, err_psnr, err_ssim
Y_0_s,
store_data=True,
keep_init=keep_init,
err_measure=err_measure,
)
(
results.loc[idx].X_adv_err[:, s],
idx_max_adv_err,
) = X_adv_err_cur.max(dim=1)
results.loc[idx].X_ref_err[:, s] = X_ref_err_cur.mean(dim=1)
for idx_noise in range(len(noise_rel)):
idx_max = idx_max_adv_err[idx_noise]
results.loc[idx].X_adv_psnr[idx_noise, s] = psnr(
rotate_real(X_adv_cur[idx_noise, ...])[idx_max, 0:1, ...],
rotate_real(X_0_s.cpu())[0, 0:1, ...],
data_range=4.5,
reduction="none",
) # normalization as in example-script
results.loc[idx].X_ref_psnr[idx_noise, s] = psnr(
rotate_real(X_ref_cur[idx_noise, ...])[:, 0:1, ...],
rotate_real(X_0_s.cpu())[:, 0:1, ...],
data_range=4.5,
reduction="mean",
) # normalization as in example-script
results.loc[idx].X_adv_ssim[idx_noise, s] = ssim(
rotate_real(X_adv_cur[idx_noise, ...])[idx_max, 0:1, ...],
rotate_real(X_0_s.cpu())[0, 0:1, ...],
data_range=4.5,
size_average=False,
def loss_func(pred, tar):
return (mseloss(
rotate_real(pred)[:, 0:1, ...],
rotate_real(tar)[:, 0:1, ...],
) / pred.shape[0])
def _complexloss(reference, prediction):
loss = mseloss(
rotate_real(reference)[:, 0:1, ...],
rotate_real(prediction)[:, 0:1, ...],
)
return loss
torchvision.transforms.Compose([
CropOrPadAndResimulate((320, 320)),
Flatten(0, -3),
Normalize(reduction="mean", use_target=True),
], ),
}
test_data = AlmostFixedMaskDataset
test_data = test_data("val", **test_data_params)
lo, hi = test_data.get_slices_in_volume(sample_vol)
print("volume slices from {} to {}, selected {}".format(
lo, hi, lo + sample_sl))
X_VOL = to_complex(
torch.stack([test_data[sl_idx][2] for sl_idx in range(lo, hi)],
dim=0)).to(device)
X_MAX = rotate_real(X_VOL)[:, 0:1, ...].max().cpu()
X_0 = to_complex(test_data[lo + sample_sl][2].to(device)).unsqueeze(0)
X_0 = X_0.repeat(it_init, *((X_0.ndim - 1) * (1, )))
Y_0 = cfg_rob.OpA(X_0)
# set range for plotting and similarity indices
v_min = 0.05
v_max = 4.50
print("Pixel values between {} and {}".format(v_min, v_max))
# create result table and load existing results from file
results = pd.DataFrame(columns=[
"name",
"X_adv_err",
"X_ref_err",
"X_adv_psnr",
"; Noise rel {}/{}".format(idx_noise + 1, len(noise_rel)) +
" (= {:1.3f})".format(noise_rel[idx_noise].item()),
flush=True,
)
noise_level = noise_rel[idx_noise] * Y_0.norm(
p=2, dim=(-2, -1), keepdim=True)
Y = noise_type(Y_0, noise_level)
X = method.reconstr(Y, noise_rel[idx_noise])
print(((Y - Y_0).norm(p=2, dim=(-2, -1)) /
(Y_0).norm(p=2, dim=(-2, -1))).mean())
results.loc[idx].X_err[idx_noise, ...] = err_measure(X, X_0)
results.loc[idx].X_psnr[idx_noise, ...] = psnr(
torch.clamp(rotate_real(X.cpu())[:, 0:1, ...], v_min, v_max),
torch.clamp(rotate_real(X_0.cpu())[:, 0:1, ...], v_min, v_max),
data_range=v_max - v_min,
reduction="none",
)
results.loc[idx].X_ssim[idx_noise, ...] = ssim(
torch.clamp(rotate_real(X.cpu())[:, 0:1, ...], v_min, v_max),
torch.clamp(rotate_real(X_0.cpu())[:, 0:1, ...], v_min, v_max),
data_range=v_max - v_min,
size_average=False,
)
results.loc[idx].X[idx_noise, ...] = X[0:1, ...].cpu()
results.loc[idx].Y[idx_noise, ...] = Y[0:1, ...].cpu()
# save results
for idx in results.index:
torchvision.transforms.Compose([
CropOrPadAndResimulate((320, 320)),
Flatten(0, -3),
Normalize(reduction="mean", use_target=True),
], ),
}
test_data = AlmostFixedMaskDataset
test_data = test_data("val", **test_data_params)
lo, hi = test_data.get_slices_in_volume(sample_vol)
print("volume slices from {} to {}, selected {}".format(
lo, hi, lo + sample_sl))
X_VOL = to_complex(
torch.stack([test_data[sl_idx][2] for sl_idx in range(lo, hi)],
dim=0)).to(device)
X_MAX = rotate_real(X_VOL)[:, 0:1, ...].max().cpu()
X_0 = to_complex(test_data[lo + sample_sl][2].to(device)).unsqueeze(0)
print(X_0.min(), X_0.max())
P_0 = _perturbation(X_0.shape[-2:])
X_0 = X_0 + P_0
print(X_0.min(), X_0.max())
Y_0 = cfg_rob.OpA(X_0)
# create result table and load existing results from file
results = pd.DataFrame(columns=["name", "X_err", "X_psnr", "X_ssim", "X", "Y"])
results.name = methods.index
results = results.set_index("name")
# load existing results from file
if os.path.isfile(save_results):
results_save = pd.read_pickle(save_results)
for idx in results_save.index:
" (= {:1.3f})".format(noise_rel[idx_noise].item()),
flush=True,
)
noise_level = noise_rel[idx_noise] * Y_0_s.norm(
p=2, dim=(-2, -1), keepdim=True)
Y = noise_type(Y_0_s, noise_level)
X = method.reconstr(Y, noise_rel[idx_noise])
print(((Y - Y_0_s).norm(p=2, dim=(-2, -1)) /
(Y_0_s).norm(p=2, dim=(-2, -1))).mean())
results.loc[idx].X_err[idx_noise,
s] = err_measure(X, X_0_s).mean()
results.loc[idx].X_psnr[idx_noise, s] = psnr(
rotate_real(X.cpu())[:, 0:1, ...],
rotate_real(X_0_s.cpu())[:, 0:1, ...],
data_range=4.5,
reduction="mean",
) # normalization as in ex-script
results.loc[idx].X_ssim[idx_noise, s] = ssim(
rotate_real(X.cpu())[:, 0:1, ...],
rotate_real(X_0_s.cpu())[:, 0:1, ...],
data_range=4.5,
size_average=True,
) # normalization as in ex-script
# save results
for idx in results.index:
results_save.loc[idx] = results.loc[idx]
os.makedirs(save_path, exist_ok=True)
