Fix sync_all_reduce to consider update->compute->update case

ignite/contrib/metrics/precision_recall_curve.py

@@ -92,11 +92,10 @@ def compute(self) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         _target_tensor = torch.cat(self._targets, dim=0)
 
         ws = idist.get_world_size()
-        if ws > 1 and not self._is_reduced:
+        if ws > 1:
             # All gather across all processes
             _prediction_tensor = cast(torch.Tensor, idist.all_gather(_prediction_tensor))
             _target_tensor = cast(torch.Tensor, idist.all_gather(_target_tensor))
-        self._is_reduced = True
 
         if idist.get_rank() == 0:
             # Run compute_fn on zero rank only

ignite/metrics/epoch_metric.py

@@ -145,11 +145,10 @@ def compute(self) -> Any:
 
         ws = idist.get_world_size()
 
-        if ws > 1 and not self._is_reduced:
+        if ws > 1:
             # All gather across all processes
             _prediction_tensor = cast(torch.Tensor, idist.all_gather(_prediction_tensor))
             _target_tensor = cast(torch.Tensor, idist.all_gather(_target_tensor))
-        self._is_reduced = True
 
         result = 0.0
         if idist.get_rank() == 0:

ignite/metrics/metric.py

@@ -214,7 +214,6 @@ def __init__(
             raise ValueError("Cannot create metric on an XLA device. Use device='cpu' instead.")
 
         self._device = torch.device(device)
-        self._is_reduced = False
         self.reset()
 
     @abstractmethod
@@ -604,7 +603,8 @@ def reinit__is_reduced(func: Callable) -> Callable:
     @wraps(func)
     def wrapper(self: Metric, *args: Any, **kwargs: Any) -> None:
         func(self, *args, **kwargs)
-        self._is_reduced = False
+        if "_result" in self.__dict__:
+            self._result = None  # type: ignore[attr-defined]
 
     setattr(wrapper, "_decorated", True)
     return wrapper

ignite/metrics/precision.py

@@ -6,7 +6,7 @@
 import ignite.distributed as idist
 from ignite.exceptions import NotComputableError
 from ignite.metrics.accuracy import _BaseClassification
-from ignite.metrics.metric import reinit__is_reduced
+from ignite.metrics.metric import reinit__is_reduced, sync_all_reduce
 from ignite.utils import to_onehot
 
 __all__ = ["Precision"]
@@ -121,6 +121,7 @@ def reset(self) -> None:
 
         super(_BasePrecisionRecall, self).reset()
 
+    @sync_all_reduce("_numerator", "_denominator")
     def compute(self) -> Union[torch.Tensor, float]:
 
         # Return value of the metric for `average` options `'weighted'` and `'macro'` is computed as follows.
@@ -138,18 +139,13 @@ def compute(self) -> Union[torch.Tensor, float]:
             raise NotComputableError(
                 f"{self.__class__.__name__} must have at least one example before it can be computed."
             )
-        if not self._is_reduced:
-            self._numerator = idist.all_reduce(self._numerator)  # type: ignore[assignment]
-            self._denominator = idist.all_reduce(self._denominator)  # type: ignore[assignment]
-            if self._average == "weighted":
-                self._weight = idist.all_reduce(self._weight)  # type: ignore[assignment]
-            self._is_reduced: bool = True
 
         fraction = self._numerator / (self._denominator + (self.eps if self._average != "samples" else 0))
 
         if self._average == "weighted":
-            sum_of_weights = cast(torch.Tensor, self._weight).sum() + self.eps
-            return ((fraction @ self._weight) / sum_of_weights).item()  # type: ignore
+            _weight = idist.all_reduce(self._weight)
+            sum_of_weights = cast(torch.Tensor, _weight).sum() + self.eps
+            return ((fraction @ _weight) / sum_of_weights).item()  # type: ignore
         elif self._average == "micro" or self._average == "samples":
             return cast(torch.Tensor, fraction).item()
         elif self._average == "macro":

tests/ignite/metrics/test_accuracy.py

@@ -286,6 +286,7 @@ def _test(metric_device):
         np_y = to_numpy_multilabel(y.cpu())  # (N, C, H, W, ...) -> (N * H * W ..., C)
         assert acc._type == "multilabel"
         res = acc.compute()
+        assert n == acc._num_examples
         assert isinstance(res, float)
         assert accuracy_score(np_y, np_y_pred) == pytest.approx(res)
 
@@ -311,8 +312,13 @@ def _test(metric_device):
 
         assert acc._type == "multilabel"
         res = acc.compute()
+        assert n == acc._num_examples
         assert isinstance(res, float)
         assert accuracy_score(np_y, np_y_pred) == pytest.approx(res)
+        # check that result is not changed
+        res = acc.compute()
+        assert n == acc._num_examples
+        assert isinstance(res, float)
 
         # Batched Updates
         acc.reset()
@@ -343,6 +349,7 @@ def _test(metric_device):
 
         assert acc._type == "multilabel"
         res = acc.compute()
+        assert n == acc._num_examples
         assert isinstance(res, float)
         assert accuracy_score(np_y, np_y_pred) == pytest.approx(res)
 

tests/ignite/metrics/test_loss.py

@@ -148,6 +148,7 @@ def _test(metric_device, y_test_1, y_test_2):
         n = loss._num_examples
         assert n == len(y)
         res = loss.compute()
+        assert n == loss._num_examples
 
         y_pred = idist.all_gather(y_pred)
         y = idist.all_gather(y)
@@ -157,7 +158,9 @@ def _test(metric_device, y_test_1, y_test_2):
         loss.reset()
         y_pred, y, _ = y_test_2
         loss.update((y_pred, y))
+        n = loss._num_examples
         res = loss.compute()
+        assert n == loss._num_examples
 
         y_pred = idist.all_gather(y_pred)
         y = idist.all_gather(y)