Test

Author: goanpeca

ignite/metrics/mean_average_precision.py

@@ -2,7 +2,6 @@
 from typing import Callable, cast, List, Optional, Sequence, Tuple, Union
 
 import torch
-from packaging.version import Version
 from typing_extensions import Literal
 
 import ignite.distributed as idist
@@ -12,9 +11,6 @@
 from ignite.utils import to_onehot
 
 
-_torch_version_lt_113 = Version(torch.__version__) < Version("1.13.0")
-
-
 class _BaseAveragePrecision:
     def __init__(
         self,
@@ -101,12 +97,9 @@ def _compute_average_precision(self, recall: torch.Tensor, precision: torch.Tens
         if self.rec_thresholds is not None:
             rec_thresholds = self.rec_thresholds.repeat((*recall.shape[:-1], 1))
             rec_thresh_indices = torch.searchsorted(recall, rec_thresholds)
-            rec_mask = rec_thresh_indices != recall.size(-1)
-            precision = torch.where(
-                rec_mask,
-                precision.take_along_dim(torch.where(rec_mask, rec_thresh_indices, 0), dim=-1),
-                0.0,
-            )
+            precision = precision.take_along_dim(
+                rec_thresh_indices.where(rec_thresh_indices != recall.size(-1), 0), dim=-1
+            ).where(rec_thresh_indices != recall.size(-1), 0)
             recall = rec_thresholds
         recall_differential = recall.diff(
             dim=-1, prepend=torch.zeros((*recall.shape[:-1], 1), device=recall.device, dtype=recall.dtype)
@@ -342,10 +335,9 @@ def _compute_recall_and_precision(
         Returns:
             `(recall, precision)`
         """
-        kwargs = {} if _torch_version_lt_113 else {"stable": True}
-        indices = torch.argsort(y_pred, descending=True, **kwargs)
+        indices = torch.argsort(y_pred, stable=True, descending=True)
         tp_summation = y_true[indices].cumsum(dim=0)
-        if tp_summation.device.type != "mps":
+        if tp_summation.device != torch.device("mps"):
             tp_summation = tp_summation.double()
 
         # Adopted from Scikit-learn's implementation
@@ -362,7 +354,7 @@ def _compute_recall_and_precision(
             recall = tp_summation / y_true_positive_count
 
         predicted_positive = tp_summation + fp_summation
-        precision = tp_summation / torch.where(predicted_positive == 0, 1.0, predicted_positive)
+        precision = tp_summation / torch.where(predicted_positive == 0, 1, predicted_positive)
         return recall, precision
 
     def compute(self) -> Union[torch.Tensor, float]:
@@ -379,7 +371,7 @@ def compute(self) -> Union[torch.Tensor, float]:
             torch.long if self._type == "multiclass" else torch.uint8,
             self._device,
         )
-        fp_precision = torch.double if self._device.type != "mps" else torch.float32
+        fp_precision = torch.double if self._device != torch.device("mps") else torch.float32
         y_pred = _cat_and_agg_tensors(self._y_pred, (num_classes,), fp_precision, self._device)
 
         if self._type == "multiclass":

ignite/metrics/vision/object_detection_average_precision_recall.py

@@ -1,7 +1,6 @@
 from typing import Callable, cast, Dict, List, Optional, Sequence, Tuple, Union
 
 import torch
-from packaging.version import Version
 from typing_extensions import Literal
 
 from ignite.metrics import MetricGroup
@@ -10,9 +9,6 @@
 from ignite.metrics.metric import Metric, reinit__is_reduced, sync_all_reduce
 
 
-_torch_version_lt_113 = Version(torch.__version__) < Version("1.13.0")
-
-
 def coco_tensor_list_to_dict_list(
     output: Tuple[
         Union[List[torch.Tensor], List[Dict[str, torch.Tensor]]],
@@ -217,8 +213,7 @@ def _compute_recall_and_precision(
         Returns:
             `(recall, precision)`
         """
-        kwargs = {} if _torch_version_lt_113 else {"stable": True}
-        indices = torch.argsort(scores, descending=True, **kwargs)
+        indices = torch.argsort(scores, dim=-1, stable=True, descending=True)
         tp = TP[..., indices]
         tp_summation = tp.cumsum(dim=-1)
         if tp_summation.device.type != "mps":
@@ -231,7 +226,7 @@ def _compute_recall_and_precision(
 
         recall = tp_summation / y_true_count
         predicted_positive = tp_summation + fp_summation
-        precision = tp_summation / torch.where(predicted_positive == 0, 1.0, predicted_positive)
+        precision = tp_summation / torch.where(predicted_positive == 0, 1, predicted_positive)
 
         return recall, precision
 
@@ -263,12 +258,9 @@ def _compute_average_precision(self, recall: torch.Tensor, precision: torch.Tens
             if recall.size(-1) != 0
             else torch.LongTensor([], device=self._device)
         )
-        recall_mask = rec_thresh_indices != recall.size(-1)
-        precision_integrand = torch.where(
-            recall_mask,
-            precision_integrand.take_along_dim(torch.where(recall_mask, rec_thresh_indices, 0), dim=-1),
-            0.0,
-        )
+        precision_integrand = precision_integrand.take_along_dim(
+            rec_thresh_indices.where(rec_thresh_indices != recall.size(-1), 0), dim=-1
+        ).where(rec_thresh_indices != recall.size(-1), 0)
         return torch.sum(precision_integrand, dim=-1) / len(cast(torch.Tensor, self.rec_thresholds))
 
     @reinit__is_reduced
@@ -306,7 +298,6 @@ def update(self, output: Tuple[List[Dict[str, torch.Tensor]], List[Dict[str, tor
                                             This key is optional.
                 ========= ================= =================================================
         """
-        kwargs = {} if _torch_version_lt_113 else {"stable": True}
         self._check_matching_input(output)
         for pred, target in zip(*output):
             labels = target["labels"]
@@ -321,7 +312,7 @@ def update(self, output: Tuple[List[Dict[str, torch.Tensor]], List[Dict[str, tor
 
             # Matching logic of object detection mAP, according to COCO reference implementation.
             if len(pred["labels"]):
-                best_detections_index = torch.argsort(pred["scores"], descending=True, **kwargs)
+                best_detections_index = torch.argsort(pred["scores"], stable=True, descending=True)
                 max_best_detections_index = torch.cat(
                     [
                         best_detections_index[pred["labels"][best_detections_index] == c][

tests/ignite/metrics/test_mean_average_precision.py

@@ -45,30 +45,30 @@ def test__prepare_output():
     metric = MeanAveragePrecision()
 
     metric._type = "binary"
-    scores, y = metric._prepare_output((torch.rand((5, 4, 3, 2)), torch.randint(0, 2, (5, 4, 3, 2))))
+    scores, y = metric._prepare_output((torch.rand((5, 4, 3, 2)), torch.randint(0, 2, (5, 4, 3, 2)).bool()))
     assert scores.shape == y.shape == (1, 120)
 
     metric._type = "multiclass"
     scores, y = metric._prepare_output((torch.rand((5, 4, 3, 2)), torch.randint(0, 4, (5, 3, 2))))
     assert scores.shape == (4, 30) and y.shape == (30,)
 
     metric._type = "multilabel"
-    scores, y = metric._prepare_output((torch.rand((5, 4, 3, 2)), torch.randint(0, 2, (5, 4, 3, 2))))
+    scores, y = metric._prepare_output((torch.rand((5, 4, 3, 2)), torch.randint(0, 2, (5, 4, 3, 2)).bool()))
     assert scores.shape == y.shape == (4, 30)
 
 
 def test_update():
     metric = MeanAveragePrecision()
     assert len(metric._y_pred) == len(metric._y_true) == 0
-    metric.update((torch.rand((5, 4)), torch.randint(0, 2, (5, 4))))
+    metric.update((torch.rand((5, 4)), torch.randint(0, 2, (5, 4)).bool()))
     assert len(metric._y_pred) == len(metric._y_true) == 1
 
 
 def test__compute_recall_and_precision():
     m = MeanAveragePrecision()
 
     scores = torch.rand((50,))
-    y_true = torch.randint(0, 2, (50,))
+    y_true = torch.randint(0, 2, (50,)).bool()
     precision, recall, _ = precision_recall_curve(y_true.numpy(), scores.numpy())
     P = y_true.sum(dim=-1)
     ignite_recall, ignite_precision = m._compute_recall_and_precision(y_true, scores, P)
@@ -77,7 +77,7 @@ def test__compute_recall_and_precision():
 
     # When there's no actual positive. Numpy expectedly raises warning.
     scores = torch.rand((50,))
-    y_true = torch.zeros((50,))
+    y_true = torch.zeros((50,)).bool()
     precision, recall, _ = precision_recall_curve(y_true.numpy(), scores.numpy())
     P = torch.tensor(0)
     ignite_recall, ignite_precision = m._compute_recall_and_precision(y_true, scores, P)
@@ -147,7 +147,7 @@ def test_compute_nonbinary_data(class_mean):
 
     # Multilabel
     m = MeanAveragePrecision(is_multilabel=True, class_mean=class_mean)
-    y_true = torch.randint(0, 2, (130, 5, 2, 2))
+    y_true = torch.randint(0, 2, (130, 5, 2, 2)).bool()
     m.update((scores[:50], y_true[:50]))
     m.update((scores[50:], y_true[50:]))
     ignite_map = m.compute().numpy()

tests/ignite/metrics/vision/test_object_detection_map.py

@@ -872,7 +872,7 @@ def test__compute_recall_and_precision(available_device):
 def test_compute(sample):
     device = idist.device()
 
-    if device.type == "mps":
+    if device == torch.device("mps"):
         pytest.skip("Due to MPS backend out of memory")
 
     # [email protected], [email protected], [email protected], AP-S, AP-M, AP-L, AR-1, AR-10, AR-100, AR-S, AR-M, AR-L
@@ -932,7 +932,7 @@ def test_integration(sample):
     bs = 3
 
     device = idist.device()
-    if device.type == "mps":
+    if device == torch.device("mps"):
         pytest.skip("Due to MPS backend out of memory")
 
     def update(engine, i):
@@ -1003,7 +1003,7 @@ def test_distrib_update_compute(distributed, sample):
 
     device = idist.device()
 
-    if device.type == "mps":
+    if device == torch.device("mps"):
         pytest.skip("Due to MPS backend out of memory")
 
     metric_device = "cpu" if device.type == "xla" else device