feat(metrics): add positive and negative likelihood ratios to ConfusionMatrixMetric

Add LR+ (sensitivity / (1 - specificity)) as requested in #4422, along
with its natural companion LR- ((1 - sensitivity) / specificity),
matching how other libraries expose the pair (e.g. torchmetrics).

Both are computed from the confusion-matrix components following the
existing pattern for compound rates (tpr/fpr guarded by class
prevalence, NaN on undefined denominator), and are exposed through the
usual aliases: 'positive likelihood ratio', 'plr', 'lr+' and
'negative likelihood ratio', 'nlr', 'lr-'.

Add tests with hand-computed values covering the undefined cases
(fpr = 0 -> LR+ is NaN, fnr = 0 -> LR- is 0) and a classification-task
integration test using the space-separated aliases.

Fixes #4422

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: LiQing <325196192+qinxwew@users.noreply.github.com>

Author: qinxwew

monai/metrics/confusion_matrix.py

@@ -43,7 +43,8 @@ class ConfusionMatrixMetric(CumulativeIterationMetric):
             ``"miss rate"``, ``"fall out"``, ``"false discovery rate"``, ``"false omission rate"``,
             ``"prevalence threshold"``, ``"threat score"``, ``"accuracy"``, ``"balanced accuracy"``,
             ``"f1 score"``, ``"matthews correlation coefficient"``, ``"fowlkes mallows index"``,
-            ``"informedness"``, ``"markedness"``]
+            ``"informedness"``, ``"markedness"``, ``"positive likelihood ratio"``,
+            ``"negative likelihood ratio"``]
             Some of the metrics have multiple aliases (as shown in the wikipedia page aforementioned),
             and you can also input those names instead.
             Except for input only one metric, multiple metrics are also supported via input a sequence of metric names, such as
@@ -185,7 +186,8 @@ def compute_confusion_matrix_metric(metric_name: str, confusion_matrix: torch.Te
             ``"miss rate"``, ``"fall out"``, ``"false discovery rate"``, ``"false omission rate"``,
             ``"prevalence threshold"``, ``"threat score"``, ``"accuracy"``, ``"balanced accuracy"``,
             ``"f1 score"``, ``"matthews correlation coefficient"``, ``"fowlkes mallows index"``,
-            ``"informedness"``, ``"markedness"``]
+            ``"informedness"``, ``"markedness"``, ``"positive likelihood ratio"``,
+            ``"negative likelihood ratio"``]
             Some of the metrics have multiple aliases (as shown in the wikipedia page aforementioned),
             and you can also input those names instead.
         confusion_matrix: Please see the doc string of the function ``get_confusion_matrix`` for more details.
@@ -263,6 +265,16 @@ def compute_confusion_matrix_metric(metric_name: str, confusion_matrix: torch.Te
         npv = torch.where((tn + fn) > 0, tn / (tn + fn), nan_tensor)
         numerator = ppv + npv - 1.0
         denominator = 1.0
+    elif metric == "plr":
+        # LR+ = sensitivity / (1 - specificity) = tpr / fpr; fpr == 0 yields NaN
+        tpr = torch.where(p > 0, tp / p, nan_tensor)
+        fpr = torch.where(n > 0, fp / n, nan_tensor)
+        numerator, denominator = tpr, fpr
+    elif metric == "nlr":
+        # LR- = (1 - sensitivity) / specificity = fnr / tnr; tnr == 0 yields NaN
+        fnr = torch.where(p > 0, fn / p, nan_tensor)
+        tnr = torch.where(n > 0, tn / n, nan_tensor)
+        numerator, denominator = fnr, tnr
     else:
         raise NotImplementedError("the metric is not implemented.")
 
@@ -319,4 +331,8 @@ def check_confusion_matrix_metric_name(metric_name: str) -> str:
         return "bm"
     if metric_name in ["markedness", "deltap", "mk"]:
         return "mk"
+    if metric_name in ["positive_likelihood_ratio", "plr", "lr+"]:
+        return "plr"
+    if metric_name in ["negative_likelihood_ratio", "nlr", "lr-"]:
+        return "nlr"
     raise NotImplementedError("the metric is not implemented.")

tests/metrics/test_compute_confusion_matrix.py

@@ -218,6 +218,24 @@
     torch.tensor([[[0.0, 0.0, 46137344.0, 0.0]]]),
 ]
 
+# 5. likelihood ratios: hand-computed LR+ / LR- values, including undefined cases
+# sample 0: tp=80, fp=20, tn=70, fn=20 -> tpr=0.8, fpr=2/9 -> LR+=3.6; fnr=0.2, tnr=7/9 -> LR-=0.25714...
+# sample 1: tp=10, fp=0,  tn=90, fn=0  -> fpr=0 -> LR+ is NaN; fnr=0 -> LR-=0.0
+TEST_CASE_LR = [torch.tensor([[80.0, 20.0, 70.0, 20.0], [10.0, 0.0, 90.0, 0.0]])]
+
+# classification-style input, channel-wise hand-computed values, no undefined cases:
+# ch0: tp=2, fp=1, tn=1, fn=1 -> LR+=4/3, LR-=2/3; ch1: tp=1, fp=1, tn=2, fn=1 -> LR+=3/2, LR-=3/4
+TEST_CASE_LR_CLF = [
+    {
+        "y_pred": torch.tensor([[1, 0], [1, 0], [0, 1], [1, 0], [0, 1]]),
+        "y": torch.tensor([[1, 0], [1, 0], [0, 1], [0, 1], [1, 0]]),
+        "include_background": True,
+        "metric_name": ["positive likelihood ratio", "negative likelihood ratio"],
+        "reduction": "sum_batch",
+    },
+    [torch.tensor([4.0 / 3.0, 3.0 / 2.0]), torch.tensor([2.0 / 3.0, 3.0 / 4.0])],
+]
+
 
 class TestConfusionMatrix(unittest.TestCase):
     @parameterized.expand([TEST_CASE_CONFUSION_MATRIX])
@@ -289,6 +307,41 @@ def test_precision(self, input_data, expected_value):
         assert_allclose(result, expected_value, atol=1e-4, rtol=1e-4)
         np.testing.assert_equal(result.device, input_data["y_pred"].device)
 
+    @parameterized.expand([TEST_CASE_LR])
+    def test_likelihood_ratios(self, confusion_matrix):
+        """Check likelihood-ratio aliases and edge cases on a per-class confusion matrix.
+
+        Args:
+            confusion_matrix: a stacked [2, 4] confusion-matrix tensor built by
+                ``compute_confusion_matrix`` for the two test classes.
+        """
+        plr = compute_confusion_matrix_metric("lr+", confusion_matrix)
+        nlr = compute_confusion_matrix_metric("lr-", confusion_matrix)
+        assert_allclose(plr[0], torch.tensor(3.6), atol=1e-4, rtol=1e-4)
+        assert_allclose(nlr[0], torch.tensor(0.2 / (70.0 / 90.0)), atol=1e-4, rtol=1e-4)
+        # fpr == 0 makes LR+ undefined (NaN by convention); fnr == 0 makes LR- equal to 0
+        self.assertTrue(torch.isnan(plr[1]))
+        assert_allclose(nlr[1], torch.tensor(0.0), atol=1e-4, rtol=1e-4)
+
+    @parameterized.expand([TEST_CASE_LR_CLF])
+    def test_likelihood_ratios_clf(self, input_data, expected_values):
+        """Check likelihood ratios through the ``ConfusionMatrixMetric`` classification API.
+
+        Args:
+            input_data: keyword arguments for ``ConfusionMatrixMetric`` plus ``y_pred``/``y``
+                to feed the metric.
+            expected_values: expected per-channel LR+ / LR- values after aggregation.
+        """
+        params = input_data.copy()
+        vals = {}
+        vals["y_pred"] = params.pop("y_pred")
+        vals["y"] = params.pop("y")
+        metric = ConfusionMatrixMetric(**params)
+        metric(**vals)
+        results = metric.aggregate()
+        for result, expected_value in zip(results, expected_values):
+            assert_allclose(result, expected_value, atol=1e-4, rtol=1e-4)
+
 
 if __name__ == "__main__":
     unittest.main()