fix bug and avoid zero division

matching_series.py

@@ -142,6 +142,8 @@ class matching_series(evaluate.Metric):
         return_coverages: bool = False,
         return_all: bool = False,
         dtype=np.float32,
+        instance_normalization: bool = False,
+        eps: float = 1e-10,
     ):
         """
         Compute the scores of the module given the predictions and references
@@ -162,6 +164,11 @@ class matching_series(evaluate.Metric):
             return_coverages = True
         predictions = np.array(predictions).astype(dtype)
         references = np.array(references).astype(dtype)
+        if instance_normalization:
+            predictions = (predictions - predictions.mean(axis=1, keepdims=True)) / predictions.std(
+                axis=1, keepdims=True
+            )
+            references = (references - references.mean(axis=1, keepdims=True)) / references.std(axis=1, keepdims=True)
         if predictions.shape[1:] != references.shape[1:]:
             raise ValueError(
                 "The number of features in the predictions and references should be the same. predictions: {}, references: {}".format(
@@ -206,7 +213,7 @@ class matching_series(evaluate.Metric):
                         )
                         distance[i : i + batch_size, j : j + batch_size] = d
         else:
-            distance = self._compute_metric(predictions[:, None], references, metric=metric, axis=1)
+            distance = self._compute_metric(predictions[:, None], references[None, :], metric=metric, axis=-2)
 
         index_distance = distance.diagonal(axis1=0, axis2=1).mean().item()
 
@@ -225,13 +232,13 @@ class matching_series(evaluate.Metric):
         best_match_inv = np.argmin(distance_mean, axis=0)
         recall_distance = distance_mean[best_match_inv, np.arange(len(best_match_inv))].mean().item()
 
-        f1_distance = 2 / (1 / precision_distance + 1 / recall_distance)
+        f1_distance = 2 / (1 / (precision_distance + eps) + 1 / (recall_distance + eps))
         mean_distance = (precision_distance + recall_distance) / 2
 
         # matching precision, recall and f1
         matching_recall = np.unique(best_match).size / len(best_match_inv)
         matching_precision = np.unique(best_match_inv).size / len(best_match)
-        matching_f1 = 2 / (1 / matching_precision + 1 / matching_recall)
+        matching_f1 = 2 / (1 / (matching_precision + eps) + 1 / (matching_recall + eps))
 
         # take matching for each feature and compute metrics for them
         precision_distance_features = []
@@ -251,7 +258,7 @@ class matching_series(evaluate.Metric):
             precision_distance_f = (distance_f[np.arange(len(best_match_f)), best_match_f].mean()).item()
             best_match_inv_f = np.argmin(distance_f, axis=0)
             recall_distance_f = (distance_f[best_match_inv_f, np.arange(len(best_match_inv_f))].mean()).item()
-            f1_distance_f = 2 / (1 / precision_distance_f + 1 / recall_distance_f)
+            f1_distance_f = 2 / (1 / (precision_distance_f + eps) + 1 / (recall_distance_f + eps))
             mean_distance_f = (precision_distance_f + recall_distance_f) / 2
             precision_distance_features.append(precision_distance_f)
             recall_distance_features.append(recall_distance_f)
@@ -261,7 +268,7 @@ class matching_series(evaluate.Metric):
 
             matching_recall_f = np.unique(best_match_f).size / len(best_match_f)
             matching_precision_f = np.unique(best_match_inv_f).size / len(best_match_inv_f)
-            matching_f1_f = 2 / (1 / matching_precision_f + 1 / matching_recall_f)
+            matching_f1_f = 2 / (1 / (matching_precision_f + eps) + 1 / (matching_recall_f + eps))
             matching_precision_features.append(matching_precision_f)
             matching_recall_features.append(matching_recall_f)
             matching_f1_features.append(matching_f1_f)