Refactor ISCO_Hierarchical_Accuracy fix recall

isco_hierarchical_accuracy.py

@@ -154,16 +154,16 @@ class ISCO_Hierarchical_Accuracy(evaluate.Metric):
 
         return isco_hierarchy
 
-    def find_ancestors(self, node: str, hierarchy: dict) -> set:
+    def find_ancestors(self, node: str, hierarchy: Dict[str, Set[str]]) -> Set[str]:
         """
         Find the ancestors of a given node in a hierarchy.
 
         Args:
             node (str): The node for which to find ancestors.
-            hierarchy (dict): A dictionary representing the hierarchy, where the keys are nodes and the values are their parents.
+            hierarchy (Dict[str, Set[str]]): A dictionary representing the hierarchy, where the keys are nodes and the values are their parents.
 
         Returns:
-            set: A set of ancestors of the given node.
+            Set[str]: A set of ancestors of the given node.
         """
         ancestors = set()
         nodes_to_visit = [node]
@@ -204,45 +204,43 @@ class ISCO_Hierarchical_Accuracy(evaluate.Metric):
         Args:
             reference_codes (List[str]): The list of reference codes.
             predicted_codes (List[str]): The list of predicted codes.
-            hierarchy (Dict[str, Set[str]]): The hierarchy definition where keys are nodes and values are sets of parent nodes.
+            hierarchy (Dict[str, Dict[str, float]]): The hierarchy definition where keys are nodes and values are dictionaries of parent nodes with distances.
 
         Returns:
             Tuple[float, float]: A tuple containing the hierarchical precision and recall floating point values.
         """
-        extended_real = {}
+        extended_real = set()
+        extended_predicted = set()
 
         # Extend the sets of reference codes with their ancestors
         for code in reference_codes:
-            weight = 1.0  # Full weight for exact match
-            extended_real[code] = weight
-            for ancestor, ancestor_weight in hierarchy.get(code, {}).items():
-                extended_real[ancestor] = max(
-                    extended_real.get(ancestor, 0), ancestor_weight
-                )
-
-        extended_predicted = {}
+            extended_real.add(code)
+            extended_real.update(self.find_ancestors(code, hierarchy))
 
         # Extend the sets of predicted codes with their ancestors
         for code in predicted_codes:
-            weight = 1.0
-            extended_predicted[code] = weight
-            for ancestor, ancestor_weight in hierarchy.get(code, {}).items():
-                extended_predicted[ancestor] = max(
-                    extended_predicted.get(ancestor, 0), ancestor_weight
-                )
-
-        # Calculate weighted correct predictions
-        correct_weights = 0
-        for code, weight in extended_predicted.items():
-            if code in extended_real:
-                correct_weights += min(weight, extended_real[code])
+            extended_predicted.add(code)
+            extended_predicted.update(self.find_ancestors(code, hierarchy))
 
-        total_predicted_weights = sum(extended_predicted.values())
-        total_real_weights = sum(extended_real.values())
+        # Calculate the intersection for recall
+        correct_recall = extended_real.intersection(extended_predicted)
 
-        # Calculate hierarchical precision and recall using weighted sums
-        hP = correct_weights / total_predicted_weights if total_predicted_weights else 0
-        hR = correct_weights / total_real_weights if total_real_weights else 0
+        # Calculate the intersection for precision
+        correct_precision = set()
+        for code in predicted_codes:
+            if code in extended_real:
+                correct_precision.add(code)
+            correct_precision.update(
+                self.find_ancestors(code, hierarchy).intersection(extended_real)
+            )
+
+        # Calculate hierarchical precision and recall using the size of intersections
+        hP = (
+            len(correct_precision) / len(extended_predicted)
+            if extended_predicted
+            else 0
+        )
+        hR = len(correct_recall) / len(extended_real) if extended_real else 0
 
         return hP, hR