more conversions to torch

Author: BanzaiTokyo

tests/ignite/metrics/regression/test_median_absolute_error.py

@@ -41,33 +41,29 @@ def test_median_absolute_error(available_device):
     # Size of dataset will be odd for these tests
 
     size = 51
-    np_y_pred = np.random.rand(size)
-    np_y = np.random.rand(size)
-    np_median_absolute_error = np.median(np.abs(np_y - np_y_pred))
+    y_pred = torch.rand(size)
+    y = torch.rand(size)
+    expected_median_absolute_error = torch.median(torch.abs(y - y_pred).cpu()).item()
 
     m = MedianAbsoluteError(device=available_device)
     assert m._device == torch.device(available_device)
-    y_pred = torch.from_numpy(np_y_pred)
-    y = torch.from_numpy(np_y)
 
     m.reset()
     m.update((y_pred, y))
 
-    assert np_median_absolute_error == pytest.approx(m.compute())
+    assert expected_median_absolute_error == pytest.approx(m.compute())
 
 
 def test_median_absolute_error_2(available_device):
     np.random.seed(1)
     size = 105
-    np_y_pred = np.random.rand(size, 1)
-    np_y = np.random.rand(size, 1)
-    np.random.shuffle(np_y)
-    np_median_absolute_error = np.median(np.abs(np_y - np_y_pred))
+    y_pred = torch.rand(size, 1)
+    y = torch.rand(size, 1)
+    y = y[torch.randperm(size)]
+    expected_median_absolute_error = torch.median(torch.abs(y - y_pred).cpu()).item()
 
     m = MedianAbsoluteError(device=available_device)
     assert m._device == torch.device(available_device)
-    y_pred = torch.from_numpy(np_y_pred)
-    y = torch.from_numpy(np_y)
 
     m.reset()
     batch_size = 16
@@ -76,24 +72,22 @@ def test_median_absolute_error_2(available_device):
         idx = i * batch_size
         m.update((y_pred[idx : idx + batch_size], y[idx : idx + batch_size]))
 
-    assert np_median_absolute_error == pytest.approx(m.compute())
+    assert expected_median_absolute_error == pytest.approx(m.compute())
 
 
 def test_integration_median_absolute_error(available_device):
     np.random.seed(1)
     size = 105
-    np_y_pred = np.random.rand(size, 1)
-    np_y = np.random.rand(size, 1)
-    np.random.shuffle(np_y)
-    np_median_absolute_error = np.median(np.abs(np_y - np_y_pred))
+    y_pred = torch.rand(size, 1)
+    y = torch.rand(size, 1)
+    y = y[torch.randperm(size)]
 
+    expected = torch.median(torch.abs(y - y_pred).cpu()).item()
     batch_size = 15
 
     def update_fn(engine, batch):
         idx = (engine.state.iteration - 1) * batch_size
-        y_true_batch = np_y[idx : idx + batch_size]
-        y_pred_batch = np_y_pred[idx : idx + batch_size]
-        return torch.from_numpy(y_pred_batch), torch.from_numpy(y_true_batch)
+        return y_pred[idx : idx + batch_size], y[idx : idx + batch_size]
 
     engine = Engine(update_fn)
 
@@ -104,7 +98,7 @@ def update_fn(engine, batch):
     data = list(range(size // batch_size))
     median_absolute_error = engine.run(data, max_epochs=1).metrics["median_absolute_error"]
 
-    assert np_median_absolute_error == pytest.approx(median_absolute_error)
+    assert expected == pytest.approx(median_absolute_error)
 
 
 def _test_distrib_compute(device):

tests/ignite/metrics/regression/test_median_absolute_percentage_error.py

@@ -41,33 +41,37 @@ def test_median_absolute_percentage_error(available_device):
     # Size of dataset will be odd for these tests
 
     size = 51
-    np_y_pred = np.random.rand(size)
-    np_y = np.random.rand(size)
-    np_median_absolute_percentage_error = 100.0 * np.median(np.abs(np_y - np_y_pred) / np.abs(np_y))
+    y_pred = torch.rand(size)
+    y = torch.rand(size)
+
+    epsilon = 1e-8
+    safe_y = torch.where(y == 0, torch.full_like(y, epsilon), y)
+    expected = torch.median(torch.abs((y - y_pred) / safe_y).cpu()).item() * 100.0
 
     m = MedianAbsolutePercentageError(device=available_device)
     assert m._device == torch.device(available_device)
-    y_pred = torch.from_numpy(np_y_pred)
-    y = torch.from_numpy(np_y)
 
     m.reset()
     m.update((y_pred, y))
 
-    assert np_median_absolute_percentage_error == pytest.approx(m.compute())
+    assert expected == pytest.approx(m.compute())
 
 
 def test_median_absolute_percentage_error_2(available_device):
     np.random.seed(1)
     size = 105
-    np_y_pred = np.random.rand(size, 1)
-    np_y = np.random.rand(size, 1)
-    np.random.shuffle(np_y)
-    np_median_absolute_percentage_error = 100.0 * np.median(np.abs(np_y - np_y_pred) / np.abs(np_y))
+    y_pred = torch.rand(size, 1)
+    y = torch.rand(size, 1)
+
+    indices = torch.randperm(size)
+    y = y[indices]
+
+    epsilon = 1e-8
+    safe_y = torch.where(y == 0, torch.full_like(y, epsilon), y)
+    expected = torch.median(torch.abs((y - y_pred) / safe_y).cpu()).item() * 100.0
 
     m = MedianAbsolutePercentageError(device=available_device)
     assert m._device == torch.device(available_device)
-    y_pred = torch.from_numpy(np_y_pred)
-    y = torch.from_numpy(np_y)
 
     m.reset()
     batch_size = 16
@@ -76,24 +80,27 @@ def test_median_absolute_percentage_error_2(available_device):
         idx = i * batch_size
         m.update((y_pred[idx : idx + batch_size], y[idx : idx + batch_size]))
 
-    assert np_median_absolute_percentage_error == pytest.approx(m.compute())
+    assert expected == pytest.approx(m.compute())
 
 
 def test_integration_median_absolute_percentage_error(available_device):
     np.random.seed(1)
     size = 105
-    np_y_pred = np.random.rand(size, 1)
-    np_y = np.random.rand(size, 1)
-    np.random.shuffle(np_y)
-    np_median_absolute_percentage_error = 100.0 * np.median(np.abs(np_y - np_y_pred) / np.abs(np_y))
+    y_pred = torch.rand(size, 1)
+    y = torch.rand(size, 1)
+
+    indices = torch.randperm(size)
+    y = y[indices]
+
+    epsilon = 1e-8
+    safe_y = torch.where(y == 0, torch.full_like(y, epsilon), y)
+    expected = torch.median(torch.abs((y - y_pred) / safe_y).cpu()).item() * 100.0
 
     batch_size = 15
 
     def update_fn(engine, batch):
         idx = (engine.state.iteration - 1) * batch_size
-        y_true_batch = np_y[idx : idx + batch_size]
-        y_pred_batch = np_y_pred[idx : idx + batch_size]
-        return torch.from_numpy(y_pred_batch), torch.from_numpy(y_true_batch)
+        return y_pred[idx : idx + batch_size], y[idx : idx + batch_size]
 
     engine = Engine(update_fn)
 
@@ -104,7 +111,7 @@ def update_fn(engine, batch):
     data = list(range(size // batch_size))
     median_absolute_percentage_error = engine.run(data, max_epochs=1).metrics["median_absolute_percentage_error"]
 
-    assert np_median_absolute_percentage_error == pytest.approx(median_absolute_percentage_error)
+    assert expected == pytest.approx(median_absolute_percentage_error)
 
 
 def _test_distrib_compute(device):

tests/ignite/metrics/regression/test_median_relative_absolute_error.py

@@ -41,33 +41,33 @@ def test_median_relative_absolute_error(available_device):
     # Size of dataset will be odd for these tests
 
     size = 51
-    np_y_pred = np.random.rand(size)
-    np_y = np.random.rand(size)
-    np_median_absolute_relative_error = np.median(np.abs(np_y - np_y_pred) / np.abs(np_y - np_y.mean()))
+    y_pred = torch.rand(size)
+    y = torch.rand(size)
+
+    baseline = torch.abs(y - y.mean())
+    expected = torch.median((torch.abs(y - y_pred) / baseline).cpu()).item()
 
     m = MedianRelativeAbsoluteError(device=available_device)
     assert m._device == torch.device(available_device)
-    y_pred = torch.from_numpy(np_y_pred)
-    y = torch.from_numpy(np_y)
 
     m.reset()
     m.update((y_pred, y))
 
-    assert np_median_absolute_relative_error == pytest.approx(m.compute())
+    assert expected == pytest.approx(m.compute())
 
 
 def test_median_relative_absolute_error_2(available_device):
     np.random.seed(1)
     size = 105
-    np_y_pred = np.random.rand(size, 1)
-    np_y = np.random.rand(size, 1)
-    np.random.shuffle(np_y)
-    np_median_absolute_relative_error = np.median(np.abs(np_y - np_y_pred) / np.abs(np_y - np_y.mean()))
+    y_pred = torch.rand(size, 1)
+    y = torch.rand(size, 1)
+    y = y[torch.randperm(size)]
+
+    baseline = torch.abs(y - y.mean())
+    expected = torch.median((torch.abs(y - y_pred) / baseline).cpu()).item()
 
     m = MedianRelativeAbsoluteError(device=available_device)
     assert m._device == torch.device(available_device)
-    y_pred = torch.from_numpy(np_y_pred)
-    y = torch.from_numpy(np_y)
 
     m.reset()
     batch_size = 16
@@ -76,24 +76,26 @@ def test_median_relative_absolute_error_2(available_device):
         idx = i * batch_size
         m.update((y_pred[idx : idx + batch_size], y[idx : idx + batch_size]))
 
-    assert np_median_absolute_relative_error == pytest.approx(m.compute())
+    assert expected == pytest.approx(m.compute())
 
 
 def test_integration_median_relative_absolute_error_with_output_transform(available_device):
     np.random.seed(1)
     size = 105
-    np_y_pred = np.random.rand(size, 1)
-    np_y = np.random.rand(size, 1)
-    np.random.shuffle(np_y)
-    np_median_absolute_relative_error = np.median(np.abs(np_y - np_y_pred) / np.abs(np_y - np_y.mean()))
+    y_pred = torch.rand(size, 1)
+    y = torch.rand(size, 1)
+    y = y[torch.randperm(size)]  # shuffle y
+
+    baseline = torch.abs(y - y.mean())
+    expected = torch.median((torch.abs(y - y_pred) / baseline.cpu()).cpu()).item()
 
     batch_size = 15
 
     def update_fn(engine, batch):
         idx = (engine.state.iteration - 1) * batch_size
-        y_true_batch = np_y[idx : idx + batch_size]
-        y_pred_batch = np_y_pred[idx : idx + batch_size]
-        return torch.from_numpy(y_pred_batch), torch.from_numpy(y_true_batch)
+        y_true_batch = y[idx : idx + batch_size]
+        y_pred_batch = y_pred[idx : idx + batch_size]
+        return y_pred_batch, y_true_batch
 
     engine = Engine(update_fn)
 
@@ -104,7 +106,7 @@ def update_fn(engine, batch):
     data = list(range(size // batch_size))
     median_absolute_relative_error = engine.run(data, max_epochs=1).metrics["median_absolute_relative_error"]
 
-    assert np_median_absolute_relative_error == pytest.approx(median_absolute_relative_error)
+    assert expected == pytest.approx(median_absolute_relative_error)
 
 
 def _test_distrib_compute(device):

tests/ignite/metrics/regression/test_pearson_correlation.py

@@ -20,6 +20,25 @@ def np_corr_eps(np_y_pred: np.ndarray, np_y: np.ndarray, eps: float = 1e-8):
     return corr
 
 
+def torch_corr_eps(y_pred: torch.Tensor, y: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+    y_pred = y_pred.to(dtype=torch.float32)
+    y = y.to(dtype=torch.float32)
+
+    y_pred_mean = y_pred.mean()
+    y_mean = y.mean()
+
+    pred_centered = y_pred - y_pred_mean
+    y_centered = y - y_mean
+
+    cov = torch.mean(pred_centered * y_centered)
+    std_pred = pred_centered.std(unbiased=False)
+    std_y = y_centered.std(unbiased=False)
+
+    denom = torch.clamp(std_pred * std_y, min=eps)
+    corr = cov / denom
+    return corr
+
+
 def scipy_corr(np_y_pred: np.ndarray, np_y: np.ndarray):
     corr = pearsonr(np_y_pred, np_y)
     return corr.statistic
@@ -51,21 +70,17 @@ def test_degenerated_sample(available_device):
     y = torch.tensor([1.0])
     m.update((y_pred, y))
 
-    np_y_pred = y_pred.numpy()
-    np_y = y_pred.numpy()
-    np_res = np_corr_eps(np_y_pred, np_y)
-    assert pytest.approx(np_res) == m.compute()
+    res = torch_corr_eps(y_pred, y)
+    assert pytest.approx(res) == m.compute()
 
     # constant samples
     m.reset()
     y_pred = torch.ones(10).float()
     y = torch.zeros(10).float()
     m.update((y_pred, y))
 
-    np_y_pred = y_pred.numpy()
-    np_y = y_pred.numpy()
-    np_res = np_corr_eps(np_y_pred, np_y)
-    assert pytest.approx(np_res) == m.compute()
+    res = torch_corr_eps(y_pred, y)
+    assert pytest.approx(res) == m.compute()
 
 
 def test_pearson_correlation(available_device):