Fix/multiclass recall macro avg ignore index

CHANGELOG.md

@@ -50,6 +50,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Fixed multiclass recall macro avg. ignore index ([#2710](https://github.com/Lightning-AI/torchmetrics/pull/2710))
+
+
 - Fixed iou scores in detection for either empty predictions/targets leading to wrong scores ([#2805](https://github.com/Lightning-AI/torchmetrics/pull/2805))
 
 

src/torchmetrics/classification/precision_recall.py

@@ -746,6 +746,7 @@ def compute(self) -> Tensor:
             fn,
             average=self.average,
             multidim_average=self.multidim_average,
+            ignore_index=self.ignore_index,
             top_k=self.top_k,
             zero_division=self.zero_division,
         )

src/torchmetrics/functional/classification/accuracy.py

@@ -85,7 +85,9 @@ def _accuracy_reduce(
         return _safe_divide(tp, tp + fn)
 
     score = _safe_divide(tp + tn, tp + tn + fp + fn) if multilabel else _safe_divide(tp, tp + fn)
-    return _adjust_weights_safe_divide(score, average, multilabel, tp, fp, fn, top_k)
+    return _adjust_weights_safe_divide(
+        score=score, average=average, multilabel=multilabel, tp=tp, fp=fp, fn=fn, top_k=top_k
+    )
 
 
 def binary_accuracy(

src/torchmetrics/functional/classification/f_beta.py

@@ -55,7 +55,7 @@ def _fbeta_reduce(
         return _safe_divide((1 + beta2) * tp, (1 + beta2) * tp + beta2 * fn + fp, zero_division)
 
     fbeta_score = _safe_divide((1 + beta2) * tp, (1 + beta2) * tp + beta2 * fn + fp, zero_division)
-    return _adjust_weights_safe_divide(fbeta_score, average, multilabel, tp, fp, fn)
+    return _adjust_weights_safe_divide(score=fbeta_score, average=average, multilabel=multilabel, tp=tp, fp=fp, fn=fn)
 
 
 def _binary_fbeta_score_arg_validation(

src/torchmetrics/functional/classification/hamming.py

@@ -80,7 +80,7 @@ def _hamming_distance_reduce(
         return 1 - _safe_divide(tp, tp + fn)
 
     score = 1 - _safe_divide(tp + tn, tp + tn + fp + fn) if multilabel else 1 - _safe_divide(tp, tp + fn)
-    return _adjust_weights_safe_divide(score, average, multilabel, tp, fp, fn)
+    return _adjust_weights_safe_divide(score=score, average=average, multilabel=multilabel, tp=tp, fp=fp, fn=fn)
 
 
 def binary_hamming_distance(

src/torchmetrics/functional/classification/negative_predictive_value.py

@@ -53,7 +53,9 @@ def _negative_predictive_value_reduce(
         fn = fn.sum(dim=0 if multidim_average == "global" else 1)
         return _safe_divide(tn, tn + fn, zero_division)
     score = _safe_divide(tn, tn + fn, zero_division)
-    return _adjust_weights_safe_divide(score, average, multilabel, tp, fp, fn, top_k=top_k)
+    return _adjust_weights_safe_divide(
+        score=score, average=average, multilabel=multilabel, tp=tp, fp=fp, fn=fn, top_k=top_k
+    )
 
 
 def binary_negative_predictive_value(

src/torchmetrics/functional/classification/precision_recall.py

@@ -43,6 +43,7 @@ def _precision_recall_reduce(
     average: Optional[Literal["binary", "micro", "macro", "weighted", "none"]],
     multidim_average: Literal["global", "samplewise"] = "global",
     multilabel: bool = False,
+    ignore_index: Optional[int] = None,
     top_k: int = 1,
     zero_division: float = 0,
 ) -> Tensor:
@@ -56,7 +57,9 @@ def _precision_recall_reduce(
         return _safe_divide(tp, tp + different_stat, zero_division)
 
     score = _safe_divide(tp, tp + different_stat, zero_division)
-    return _adjust_weights_safe_divide(score, average, multilabel, tp, fp, fn, top_k=top_k)
+    return _adjust_weights_safe_divide(
+        score=score, average=average, multilabel=multilabel, tp=tp, fp=fp, fn=fn, ignore_index=ignore_index, top_k=top_k
+    )
 
 
 def binary_precision(

src/torchmetrics/functional/classification/specificity.py

@@ -51,7 +51,9 @@ def _specificity_reduce(
         return _safe_divide(tn, tn + fp)
 
     specificity_score = _safe_divide(tn, tn + fp)
-    return _adjust_weights_safe_divide(specificity_score, average, multilabel, tp, fp, fn)
+    return _adjust_weights_safe_divide(
+        score=specificity_score, average=average, multilabel=multilabel, tp=tp, fp=fp, fn=fn
+    )
 
 
 def binary_specificity(

src/torchmetrics/utilities/compute.py

@@ -61,7 +61,14 @@ def _safe_divide(num: Tensor, denom: Tensor, zero_division: float = 0.0) -> Tens
 
 
 def _adjust_weights_safe_divide(
-    score: Tensor, average: Optional[str], multilabel: bool, tp: Tensor, fp: Tensor, fn: Tensor, top_k: int = 1
+    score: Tensor,
+    average: Optional[str],
+    multilabel: bool,
+    tp: Tensor,
+    fp: Tensor,
+    fn: Tensor,
+    top_k: int = 1,
+    ignore_index: Optional[int] = None,
 ) -> Tensor:
     if average is None or average == "none":
         return score
@@ -71,6 +78,10 @@ def _adjust_weights_safe_divide(
         weights = torch.ones_like(score)
         if not multilabel:
             weights[tp + fp + fn == 0 if top_k == 1 else tp + fn == 0] = 0.0
+
+    if ignore_index is not None and 0 <= ignore_index < len(score):
+        weights[ignore_index] = 0.0
+
     return _safe_divide(weights * score, weights.sum(-1, keepdim=True)).sum(-1)
 
 

tests/unittests/classification/test_precision_recall.py

@@ -659,6 +659,37 @@ def test_corner_case():
     assert res == 1.0
 
 
+def test_multiclass_recall_ignore_index():
+    """Issue: https://github.com/Lightning-AI/torchmetrics/issues/2441."""
+    y_true = torch.tensor([0, 0, 1, 1])
+    y_pred = torch.tensor([
+        [0.9, 0.1],
+        [0.9, 0.1],
+        [0.9, 0.1],
+        [0.1, 0.9],
+    ])
+
+    # Test with ignore_index=0 and average="macro"
+    metric_ignore_0 = MulticlassRecall(num_classes=2, ignore_index=0, average="macro")
+    res_ignore_0 = metric_ignore_0(y_pred, y_true)
+    assert res_ignore_0 == 0.5, f"Expected 0.5, but got {res_ignore_0}"
+
+    # Test with ignore_index=1 and average="macro"
+    metric_ignore_1 = MulticlassRecall(num_classes=2, ignore_index=1, average="macro")
+    res_ignore_1 = metric_ignore_1(y_pred, y_true)
+    assert res_ignore_1 == 1.0, f"Expected 1.0, but got {res_ignore_1}"
+
+    # Test with no ignore_index and average="macro"
+    metric_no_ignore = MulticlassRecall(num_classes=2, average="macro")
+    res_no_ignore = metric_no_ignore(y_pred, y_true)
+    assert res_no_ignore == 0.75, f"Expected 0.75, but got {res_no_ignore}"
+
+    # Test with ignore_index=0 and average="none"
+    metric_none = MulticlassRecall(num_classes=2, ignore_index=0, average="none")
+    res_none = metric_none(y_pred, y_true)
+    assert torch.allclose(res_none, torch.tensor([0.0, 0.5])), f"Expected [0.0, 0.5], but got {res_none}"
+
+
 @pytest.mark.parametrize(
     ("metric", "kwargs", "base_metric"),
     [