add available device to regression tests #3335

ignite/metrics/regression/_base.py

@@ -30,6 +30,10 @@ def _check_output_types(output: Tuple[torch.Tensor, torch.Tensor]) -> None:
 
 
 def _torch_median(output: torch.Tensor) -> float:
+    # torch.kthvalue used later is not supported on MPS
+    if output.device.type == "mps":
+        output = output.cpu()
+
     output = output.view(-1)
     len_ = len(output)
 

ignite/metrics/regression/fractional_bias.py

@@ -64,7 +64,7 @@ class FractionalBias(_BaseRegression):
 
     @reinit__is_reduced
     def reset(self) -> None:
-        self._sum_of_errors = torch.tensor(0.0, dtype=torch.double, device=self._device)
+        self._sum_of_errors = torch.tensor(0.0, dtype=self._double_dtype, device=self._device)
         self._num_examples = 0
 
     def _update(self, output: Tuple[torch.Tensor, torch.Tensor]) -> None:

ignite/metrics/regression/pearson_correlation.py

@@ -119,5 +119,12 @@ def compute(self) -> float:
         y_var = self._sum_of_y_squares / n - y_mean * y_mean
         y_var = torch.clamp(y_var, min=0.0)
 
-        r = cov / torch.clamp(torch.sqrt(y_pred_var * y_var), min=self.eps)
+        denom = y_pred_var * y_var
+        denom = torch.clamp(denom, min=self.eps)
+        denom = torch.sqrt(denom)
+        r = cov / denom
+
+        if torch.isnan(r):
+            return 0.0
+
         return float(r.item())

tests/ignite/metrics/regression/test_canberra_metric.py

@@ -20,83 +20,83 @@ def test_wrong_input_shapes():
         m.update((torch.rand(4, 1), torch.rand(4)))
 
 
-def test_compute():
-    a = np.random.randn(4)
-    b = np.random.randn(4)
-    c = np.random.randn(4)
-    d = np.random.randn(4)
-    ground_truth = np.random.randn(4)
+def test_compute(available_device):
+    a = torch.randn(4)
+    b = torch.randn(4)
+    c = torch.randn(4)
+    d = torch.randn(4)
+    ground_truth = torch.randn(4)
 
-    m = CanberraMetric()
+    m = CanberraMetric(device=available_device)
+    assert m._device == torch.device(available_device)
 
     canberra = DistanceMetric.get_metric("canberra")
 
-    m.update((torch.from_numpy(a), torch.from_numpy(ground_truth)))
-    np_sum = (np.abs(ground_truth - a) / (np.abs(a) + np.abs(ground_truth))).sum()
+    m.update((a, ground_truth))
+    np_sum = (torch.abs(ground_truth - a) / (torch.abs(a) + torch.abs(ground_truth))).sum()
     assert m.compute() == pytest.approx(np_sum)
-    assert canberra.pairwise([a, ground_truth])[0][1] == pytest.approx(np_sum)
+    assert canberra.pairwise([a.cpu().numpy(), ground_truth.cpu().numpy()])[0][1] == pytest.approx(np_sum)
 
-    m.update((torch.from_numpy(b), torch.from_numpy(ground_truth)))
-    np_sum += ((np.abs(ground_truth - b)) / (np.abs(b) + np.abs(ground_truth))).sum()
+    m.update((b, ground_truth))
+    np_sum += ((torch.abs(ground_truth - b)) / (torch.abs(b) + torch.abs(ground_truth))).sum()
     assert m.compute() == pytest.approx(np_sum)
     v1 = np.hstack([a, b])
     v2 = np.hstack([ground_truth, ground_truth])
     assert canberra.pairwise([v1, v2])[0][1] == pytest.approx(np_sum)
 
-    m.update((torch.from_numpy(c), torch.from_numpy(ground_truth)))
-    np_sum += ((np.abs(ground_truth - c)) / (np.abs(c) + np.abs(ground_truth))).sum()
+    m.update((c, ground_truth))
+    np_sum += ((torch.abs(ground_truth - c)) / (torch.abs(c) + torch.abs(ground_truth))).sum()
     assert m.compute() == pytest.approx(np_sum)
     v1 = np.hstack([v1, c])
     v2 = np.hstack([v2, ground_truth])
     assert canberra.pairwise([v1, v2])[0][1] == pytest.approx(np_sum)
 
-    m.update((torch.from_numpy(d), torch.from_numpy(ground_truth)))
-    np_sum += (np.abs(ground_truth - d) / (np.abs(d) + np.abs(ground_truth))).sum()
+    m.update((d, ground_truth))
+    np_sum += (torch.abs(ground_truth - d) / (torch.abs(d) + torch.abs(ground_truth))).sum()
     assert m.compute() == pytest.approx(np_sum)
     v1 = np.hstack([v1, d])
     v2 = np.hstack([v2, ground_truth])
     assert canberra.pairwise([v1, v2])[0][1] == pytest.approx(np_sum)
 
 
-def test_integration():
-    def _test(y_pred, y, batch_size):
-        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)
-
-        engine = Engine(update_fn)
+@pytest.mark.parametrize("n_times", range(3))
+@pytest.mark.parametrize(
+    "test_cases",
+    [
+        (torch.rand(size=(100,)), torch.rand(size=(100,)), 10),
+        (torch.rand(size=(100, 1)), torch.rand(size=(100, 1)), 20),
+    ],
+)
+def test_integration(n_times, test_cases, available_device):
+    y_pred, y, batch_size = test_cases
 
-        m = CanberraMetric()
-        m.attach(engine, "cm")
+    def update_fn(engine, batch):
+        idx = (engine.state.iteration - 1) * batch_size
+        y_true_batch = y[idx : idx + batch_size]
+        y_pred_batch = y_pred[idx : idx + batch_size]
+        return y_pred_batch, y_true_batch
 
-        np_y = y.numpy().ravel()
-        np_y_pred = y_pred.numpy().ravel()
+    engine = Engine(update_fn)
 
-        canberra = DistanceMetric.get_metric("canberra")
+    m = CanberraMetric(device=available_device)
+    assert m._device == torch.device(available_device)
 
-        data = list(range(y_pred.shape[0] // batch_size))
-        cm = engine.run(data, max_epochs=1).metrics["cm"]
+    m.attach(engine, "cm")
 
-        assert canberra.pairwise([np_y_pred, np_y])[0][1] == pytest.approx(cm)
+    canberra = DistanceMetric.get_metric("canberra")
 
-    def get_test_cases():
-        test_cases = [
-            (torch.rand(size=(100,)), torch.rand(size=(100,)), 10),
-            (torch.rand(size=(100, 1)), torch.rand(size=(100, 1)), 20),
-        ]
-        return test_cases
+    data = list(range(y_pred.shape[0] // batch_size))
+    cm = engine.run(data, max_epochs=1).metrics["cm"]
 
-    for _ in range(5):
-        # check multiple random inputs as random exact occurencies are rare
-        test_cases = get_test_cases()
-        for y_pred, y, batch_size in test_cases:
-            _test(y_pred, y, batch_size)
+    pred_np = y_pred.cpu().numpy().reshape(len(y_pred), -1)
+    true_np = y.cpu().numpy().reshape(len(y), -1)
+    expected = np.sum(canberra.pairwise(pred_np, true_np).diagonal())
+    assert expected == pytest.approx(cm)
 
 
-def test_error_is_not_nan():
-    m = CanberraMetric()
+def test_error_is_not_nan(available_device):
+    m = CanberraMetric(device=available_device)
+    assert m._device == torch.device(available_device)
     m.update((torch.zeros(4), torch.zeros(4)))
     assert not (torch.isnan(m._sum_of_errors).any() or torch.isinf(m._sum_of_errors).any()), m._sum_of_errors
 

tests/ignite/metrics/regression/test_fractional_absolute_error.py

@@ -28,77 +28,66 @@ def test_wrong_input_shapes():
         m.update((torch.rand(4, 1), torch.rand(4)))
 
 
-def test_compute():
-    a = np.random.randn(4)
-    b = np.random.randn(4)
-    c = np.random.randn(4)
-    d = np.random.randn(4)
-    ground_truth = np.random.randn(4)
+def test_compute(available_device):
+    a = torch.randn(4)
+    b = torch.randn(4)
+    c = torch.randn(4)
+    d = torch.randn(4)
+    ground_truth = torch.randn(4)
 
-    m = FractionalAbsoluteError()
+    m = FractionalAbsoluteError(device=available_device)
+    assert m._device == torch.device(available_device)
 
-    m.update((torch.from_numpy(a), torch.from_numpy(ground_truth)))
-    np_sum = (2 * np.abs((a - ground_truth)) / (np.abs(a) + np.abs(ground_truth))).sum()
-    np_len = len(a)
-    np_ans = np_sum / np_len
-    assert m.compute() == pytest.approx(np_ans)
+    total_error = 0.0
+    total_len = 0
 
-    m.update((torch.from_numpy(b), torch.from_numpy(ground_truth)))
-    np_sum += (2 * np.abs((b - ground_truth)) / (np.abs(b) + np.abs(ground_truth))).sum()
-    np_len += len(b)
-    np_ans = np_sum / np_len
-    assert m.compute() == pytest.approx(np_ans)
+    for pred in [a, b, c, d]:
+        m.update((pred, ground_truth))
 
-    m.update((torch.from_numpy(c), torch.from_numpy(ground_truth)))
-    np_sum += (2 * np.abs((c - ground_truth)) / (np.abs(c) + np.abs(ground_truth))).sum()
-    np_len += len(c)
-    np_ans = np_sum / np_len
-    assert m.compute() == pytest.approx(np_ans)
+        # Compute fractional absolute error in PyTorch
+        error = 2 * torch.abs(pred - ground_truth) / (torch.abs(pred) + torch.abs(ground_truth))
+        total_error += error.sum().item()
+        total_len += len(pred)
 
-    m.update((torch.from_numpy(d), torch.from_numpy(ground_truth)))
-    np_sum += (2 * np.abs((d - ground_truth)) / (np.abs(d) + np.abs(ground_truth))).sum()
-    np_len += len(d)
-    np_ans = np_sum / np_len
-    assert m.compute() == pytest.approx(np_ans)
+        expected = total_error / total_len
+        assert m.compute() == pytest.approx(expected)
 
 
-def test_integration():
-    def _test(y_pred, y, batch_size):
-        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)
+@pytest.mark.parametrize("n_times", range(5))
+@pytest.mark.parametrize(
+    "test_cases",
+    [
+        (torch.rand(size=(100,)), torch.rand(size=(100,)), 10),
+        (torch.rand(size=(100, 1)), torch.rand(size=(100, 1)), 20),
+    ],
+)
+def test_integration_fractional_absolute_error(n_times, test_cases, available_device):
+    y_pred, y, batch_size = test_cases
 
-        engine = Engine(update_fn)
+    np_y = y.numpy().ravel()
+    np_y_pred = y_pred.numpy().ravel()
 
-        m = FractionalAbsoluteError()
-        m.attach(engine, "fab")
+    def update_fn(engine, batch):
+        idx = (engine.state.iteration - 1) * batch_size
+        y_true_batch = y[idx : idx + batch_size]
+        y_pred_batch = y_pred[idx : idx + batch_size]
+        return y_pred_batch, y_true_batch
 
-        np_y = y.numpy().ravel()
-        np_y_pred = y_pred.numpy().ravel()
+    engine = Engine(update_fn)
 
-        data = list(range(y_pred.shape[0] // batch_size))
-        fab = engine.run(data, max_epochs=1).metrics["fab"]
+    metric = FractionalAbsoluteError(device=available_device)
+    assert metric._device == torch.device(available_device)
 
-        np_sum = (2 * np.abs((np_y_pred - np_y)) / (np.abs(np_y_pred) + np.abs(np_y))).sum()
-        np_len = len(y_pred)
-        np_ans = np_sum / np_len
+    metric.attach(engine, "fab")
 
-        assert np_ans == pytest.approx(fab)
+    data = list(range(y_pred.shape[0] // batch_size))
+    fab = engine.run(data, max_epochs=1).metrics["fab"]
 
-    def get_test_cases():
-        test_cases = [
-            (torch.rand(size=(100,)), torch.rand(size=(100,)), 10),
-            (torch.rand(size=(100, 1)), torch.rand(size=(100, 1)), 20),
-        ]
-        return test_cases
+    # Expected result using NumPy
+    np_sum = (2 * np.abs(np_y_pred - np_y) / (np.abs(np_y_pred) + np.abs(np_y))).sum()
+    expected = np_sum / len(np_y)
 
-    for _ in range(5):
-        # check multiple random inputs as random exact occurencies are rare
-        test_cases = get_test_cases()
-        for y_pred, y, batch_size in test_cases:
-            _test(y_pred, y, batch_size)
+    assert expected == pytest.approx(fab)
 
 
 def _test_distrib_compute(device):