def test_psnr_base_e_wider_range(pred, target):
score = psnr(pred=torch.tensor(pred),
target=torch.tensor(target),
data_range=4,
base=2.718281828459045)
sk_score = ski_psnr(np.array(pred), np.array(target), data_range=4) * np.log(10)
assert torch.allclose(score, torch.tensor(sk_score, dtype=torch.float32), atol=1e-3)
def test_psnr_with_skimage(pred, target):
score = psnr(pred=torch.tensor(pred),
target=torch.tensor(target),
data_range=3)
sk_score = ski_psnr(np.array(pred), np.array(target), data_range=3)
assert torch.allclose(score,
torch.tensor(sk_score, dtype=torch.float),
atol=1e-3)
def _test_psnr(y_pred, y, data_range, device):
psnr = PSNR(data_range=data_range, device=device)
psnr.update((y_pred, y))
psnr_compute = psnr.compute()
np_y_pred = y_pred.cpu().numpy()
np_y = y.cpu().numpy()
np_psnr = 0
for np_y_pred_, np_y_ in zip(np_y_pred, np_y):
np_psnr += ski_psnr(np_y_, np_y_pred_, data_range=data_range)
assert torch.gt(psnr_compute, 0.0)
assert isinstance(psnr_compute, torch.Tensor)
assert psnr_compute.dtype == torch.float64
assert psnr_compute.device == torch.device(device)
assert np.allclose(psnr_compute.numpy(), np_psnr / np_y.shape[0])
def _test(
y_pred,
y,
data_range,
metric_device,
n_iters,
s,
offset,
rank,
atol,
output_transform=lambda x: x,
compute_y_channel=False,
):
from ignite.engine import Engine
def update(engine, i):
return (
y_pred[i * s + offset * rank:(i + 1) * s + offset * rank],
y[i * s + offset * rank:(i + 1) * s + offset * rank],
)
engine = Engine(update)
PSNR(data_range=data_range,
output_transform=output_transform,
device=metric_device).attach(engine, "psnr")
data = list(range(n_iters))
engine.run(data=data, max_epochs=1)
result = engine.state.metrics["psnr"]
assert result > 0.0
assert "psnr" in engine.state.metrics
if compute_y_channel:
np_y_pred = y_pred[:, 0, ...].cpu().numpy()
np_y = y[:, 0, ...].cpu().numpy()
else:
np_y_pred = y_pred.cpu().numpy()
np_y = y.cpu().numpy()
np_psnr = 0
for np_y_pred_, np_y_ in zip(np_y_pred, np_y):
np_psnr += ski_psnr(np_y_, np_y_pred_, data_range=data_range)
assert np.allclose(result, np_psnr / np_y.shape[0], atol=atol)
(epoch, ti)),
padding=0,
normalize=True)
# Calculate SSIM and PSNR
fakeB = fakeB.data.cpu().numpy()
realB = realB.data.cpu().numpy()
fakeB = fakeB.transpose(
(0, 2, 3, 1)) # N C H W ---> N H W C
realB = realB.transpose(
(0, 2, 3, 1)) # N C H W ---> N H W C
fakeB = np.clip(fakeB, a_min=0.0, a_max=1.0)
realB = np.clip(realB, a_min=0.0, a_max=1.0)
for _bti in range(fakeB.shape[0]):
per_fakeB = fakeB[_bti]
per_realB = realB[_bti]
test_ssim += ski_ssim(per_fakeB,
per_realB,
data_range=1,
multichannel=True)
test_psnr += ski_psnr(per_realB,
per_fakeB,
data_range=1)
test_ite += 1
test_psnr /= test_ite
test_ssim /= test_ite
print(' Valid PSNR: {:.4f}'.format(test_psnr))
print(' Valid SSIM: {:.4f}'.format(test_ssim))
print('------------------------')
pytest.param([4., 3., 2., 1.], [1., 4., 3., 2.], .2841)
])
def test_rmsle(pred, target, exp):
rmsle = RMSLE()
assert rmsle.name == 'rmsle'
score = rmsle(pred=torch.tensor(pred), target=torch.tensor(target))
assert isinstance(score, torch.Tensor)
assert pytest.approx(score.item(), rel=1e-3) == exp
@pytest.mark.parametrize(['pred', 'target', 'exp'], [
pytest.param([0., 1., 2., 3.], [0., 1., 2., 2.],
ski_psnr(np.array([0., 1., 2., 3.]),
np.array([0., 1., 2., 2.]),
data_range=3)),
pytest.param([4., 3., 2., 1.], [1., 4., 3., 2.],
ski_psnr(np.array([4., 3., 2., 1.]),
np.array([1., 4., 3., 2.]),
data_range=3))
])
def test_psnr(pred, target, exp):
psnr = PSNR()
assert psnr.name == 'psnr'
score = psnr(pred=torch.tensor(pred), target=torch.tensor(target))
assert isinstance(score, torch.Tensor)
assert pytest.approx(score.item(), rel=1e-3) == exp
@pytest.mark.parametrize(['pred', 'target', 'exp'], [