Merge branch 'master' into rewrite-engine-terminate-and-co

Author: vfdev-5

ignite/metrics/gan/fid.py

@@ -12,6 +12,12 @@
 ]
 
 
+if Version(torch.__version__) <= Version("1.7.0"):
+    torch_outer = torch.ger
+else:
+    torch_outer = torch.outer
+
+
 def fid_score(
     mu1: torch.Tensor, mu2: torch.Tensor, sigma1: torch.Tensor, sigma2: torch.Tensor, eps: float = 1e-6
 ) -> float:
@@ -193,22 +199,14 @@ def __init__(
     def _online_update(features: torch.Tensor, total: torch.Tensor, sigma: torch.Tensor) -> None:
 
         total += features
-
-        if Version(torch.__version__) <= Version("1.7.0"):
-            sigma += torch.ger(features, features)
-        else:
-            sigma += torch.outer(features, features)
+        sigma += torch_outer(features, features)
 
     def _get_covariance(self, sigma: torch.Tensor, total: torch.Tensor) -> torch.Tensor:
         r"""
         Calculates covariance from mean and sum of products of variables
         """
 
-        if Version(torch.__version__) <= Version("1.7.0"):
-            sub_matrix = torch.ger(total, total)
-        else:
-            sub_matrix = torch.outer(total, total)
-
+        sub_matrix = torch_outer(total, total)
         sub_matrix = sub_matrix / self._num_examples
 
         return (sigma - sub_matrix) / (self._num_examples - 1)

tests/ignite/contrib/metrics/test_average_precision.py

@@ -215,11 +215,9 @@ def get_test_cases():
 def _test_distrib_integration_binary_input(device):
 
     rank = idist.get_rank()
-    torch.manual_seed(12)
     n_iters = 80
-    s = 16
+    batch_size = 16
     n_classes = 2
-    offset = n_iters * s
 
     def _test(y_preds, y_true, n_epochs, metric_device, update_fn):
         metric_device = torch.device(metric_device)
@@ -232,6 +230,9 @@ def _test(y_preds, y_true, n_epochs, metric_device, update_fn):
         data = list(range(n_iters))
         engine.run(data=data, max_epochs=n_epochs)
 
+        y_true = idist.all_gather(y_true)
+        y_preds = idist.all_gather(y_preds)
+
         assert "ap" in engine.state.metrics
 
         res = engine.state.metrics["ap"]
@@ -240,24 +241,25 @@ def _test(y_preds, y_true, n_epochs, metric_device, update_fn):
         assert pytest.approx(res) == true_res
 
     def get_tests(is_N):
+        torch.manual_seed(12 + rank)
         if is_N:
-            y_true = torch.randint(0, n_classes, size=(offset * idist.get_world_size(),)).to(device)
-            y_preds = torch.rand(offset * idist.get_world_size()).to(device)
+            y_true = torch.randint(0, n_classes, size=(n_iters * batch_size,)).to(device)
+            y_preds = torch.rand(n_iters * batch_size).to(device)
 
             def update_fn(engine, i):
                 return (
-                    y_preds[i * s + rank * offset : (i + 1) * s + rank * offset],
-                    y_true[i * s + rank * offset : (i + 1) * s + rank * offset],
+                    y_preds[i * batch_size : (i + 1) * batch_size],
+                    y_true[i * batch_size : (i + 1) * batch_size],
                 )
 
         else:
-            y_true = torch.randint(0, n_classes, size=(offset * idist.get_world_size(), 10)).to(device)
-            y_preds = torch.randint(0, n_classes, size=(offset * idist.get_world_size(), 10)).to(device)
+            y_true = torch.randint(0, n_classes, size=(n_iters * batch_size, 10)).to(device)
+            y_preds = torch.randint(0, n_classes, size=(n_iters * batch_size, 10)).to(device)
 
             def update_fn(engine, i):
                 return (
-                    y_preds[i * s + rank * offset : (i + 1) * s + rank * offset, :],
-                    y_true[i * s + rank * offset : (i + 1) * s + rank * offset, :],
+                    y_preds[i * batch_size : (i + 1) * batch_size, :],
+                    y_true[i * batch_size : (i + 1) * batch_size, :],
                 )
 
         return y_preds, y_true, update_fn