Improve precision recall metric issue 2571

ignite/metrics/classification_report.py

@@ -4,7 +4,6 @@
 import torch
 
 from ignite.metrics.fbeta import Fbeta
-from ignite.metrics.metric import Metric
 from ignite.metrics.metrics_lambda import MetricsLambda
 from ignite.metrics.precision import Precision
 from ignite.metrics.recall import Recall
@@ -85,14 +84,14 @@ def ClassificationReport(
                 [0, 0, 0],
                 [1, 0, 0],
                 [0, 1, 1],
-            ]).unsqueeze(0)
+            ])
             y_pred = torch.tensor([
                 [1, 1, 0],
                 [1, 0, 1],
                 [1, 0, 0],
                 [1, 0, 1],
                 [1, 1, 0],
-            ]).unsqueeze(0)
+            ])
             state = default_evaluator.run([[y_pred, y_true]])
             print(state.metrics["cr"].keys())
             print(state.metrics["cr"]["0"])
@@ -119,25 +118,24 @@ def ClassificationReport(
     averaged_fbeta = fbeta.mean()
 
     def _wrapper(
-        recall_metric: Metric, precision_metric: Metric, f: Metric, a_recall: Metric, a_precision: Metric, a_f: Metric
+        re: torch.Tensor, pr: torch.Tensor, f: torch.Tensor, a_re: torch.Tensor, a_pr: torch.Tensor, a_f: torch.Tensor
     ) -> Union[Collection[str], Dict]:
-        p_tensor, r_tensor, f_tensor = precision_metric, recall_metric, f
-        if p_tensor.shape != r_tensor.shape:
+        if pr.shape != re.shape:
             raise ValueError(
                 "Internal error: Precision and Recall have mismatched shapes: "
-                f"{p_tensor.shape} vs {r_tensor.shape}. Please, open an issue "
+                f"{pr.shape} vs {re.shape}. Please, open an issue "
                 "with a reference on this error. Thank you!"
             )
         dict_obj = {}
-        for idx, p_label in enumerate(p_tensor):
+        for idx, p_label in enumerate(pr):
             dict_obj[_get_label_for_class(idx)] = {
                 "precision": p_label.item(),
-                "recall": r_tensor[idx].item(),
-                "f{0}-score".format(beta): f_tensor[idx].item(),
+                "recall": re[idx].item(),
+                "f{0}-score".format(beta): f[idx].item(),
             }
         dict_obj["macro avg"] = {
-            "precision": a_precision.item(),
-            "recall": a_recall.item(),
+            "precision": a_pr.item(),
+            "recall": a_re.item(),
             "f{0}-score".format(beta): a_f.item(),
         }
         return dict_obj if output_dict else json.dumps(dict_obj)

ignite/metrics/fbeta.py

@@ -56,8 +56,8 @@ def Fbeta(
 
         .. testcode:: 1
 
-            P = Precision(average=False)
-            R = Recall(average=False)
+            P = Precision(average=False)[1] # `[1]` is to select the value for class 1 that is TP/(TP+FP)
+            R = Recall(average=False)[1] # `[1]` is to select the value for class 1 that is TP/(TP+FN)
             metric = Fbeta(beta=1.0, precision=P, recall=R)
             metric.attach(default_evaluator, "f-beta")
             y_true = torch.tensor([1, 0, 1, 1, 0, 1])
@@ -127,8 +127,8 @@ def thresholded_output_transform(output):
                 y_pred = torch.round(y_pred)
                 return y_pred, y
 
-            P = Precision(average=False, output_transform=thresholded_output_transform)
-            R = Recall(average=False, output_transform=thresholded_output_transform)
+            P = Precision(average=False, output_transform=thresholded_output_transform)[1]
+            R = Recall(average=False, output_transform=thresholded_output_transform)[1]
             metric = Fbeta(beta=1.0, precision=P, recall=R)
             metric.attach(default_evaluator, "f-beta")
             y_true = torch.tensor([1, 0, 1, 1, 0, 1])

ignite/metrics/metrics_lambda.py

@@ -36,8 +36,8 @@ class MetricsLambda(Metric):
 
         .. testcode::
 
-            precision = Precision(average=False)
-            recall = Recall(average=False)
+            precision = Precision(average=False)[1] # `[1]` is to select the value for class 1 that is TP/(TP+FP)
+            recall = Recall(average=False)[1] # `[1]` is to select the value for class 1 that is TP/(TP+FN)
 
             def Fbeta(r, p, beta):
                 return torch.mean((1 + beta ** 2) * p * r / (beta ** 2 * p + r + 1e-20)).item()