Refactor hierarchical precision and recall calculation***

ham.py

@@ -1,40 +1,53 @@
-def ancestors(class_label, hierarchy):
-    """Return all ancestors of a given class label, excluding the root."""
-    if class_label not in hierarchy or not hierarchy[class_label]:
-        return set()
-    else:
-        # Recursively get all ancestors for each parent
-        anc = set(hierarchy[class_label])
-        for parent in hierarchy[class_label]:
-            anc.update(ancestors(parent, hierarchy))
-        return anc
-
-
-def extend_with_ancestors(class_labels, hierarchy):
-    """Extend a set of class labels with their ancestors."""
-    extended_set = set(class_labels)
-    for label in class_labels:
-        extended_set.update(ancestors(label, hierarchy))
-    return extended_set
-
-
-def hierarchical_precision_recall(true_labels, predicted_labels, hierarchy):
-    """Calculate hierarchical precision and recall."""
-    true_extended = [extend_with_ancestors(ci, hierarchy) for ci in true_labels]
-    predicted_extended = [
-        extend_with_ancestors(c_prime_i, hierarchy) for c_prime_i in predicted_labels
+def find_ancestors(tree, code):
+    """
+    Recursively finds ancestors of a given class (e.g., an ISCO-08 code) in a hierarchical JSON structure.
+
+    Args:
+    - tree: A dictionary representing the hierarchical structure.
+    - code: A string representing the label of the class.
+
+    Returns:
+    - A list of strings, each representing an ancestor of the input class.
+    """
+    ancestors = []
+    current = code
+    while current:
+        parent = tree[current]["parent"]
+        if parent:
+            ancestors.append(parent)
+        current = parent
+    return ancestors
+
+
+def calculate_hierarchical_measures(true_labels, predicted_labels, tree):
+    """
+    Calculates hierarchical precision, recall, and F-measure in a hierarchical structure.
+
+    Args:
+    - true_labels: A list of strings representing true class labels.
+    - predicted_labels: A list of strings representing predicted class labels.
+    - tree: A dictionary representing the hierarchical structure.
+
+    Returns:
+    - hP: A floating point number representing hierarchical precision.
+    - hR: A floating point number representing hierarchical recall.
+    - hF: A floating point number representing hierarchical F-measure.
+    """
+
+    extended_true = [set(find_ancestors(tree, code) | {code}) for code in true_labels]
+    extended_pred = [
+        set(find_ancestors(tree, code) | {code}) for code in predicted_labels
     ]
 
-    intersect_sum = sum(
-        len(ci & c_prime_i) for ci, c_prime_i in zip(true_extended, predicted_extended)
-    )
-    predicted_sum = sum(len(c_prime_i) for c_prime_i in predicted_extended)
-    true_sum = sum(len(ci) for ci in true_extended)
+    true_positive = sum(len(t & p) for t, p in zip(extended_true, extended_pred))
+    predicted = sum(len(p) for p in extended_pred)
+    actual = sum(len(t) for t in extended_true)
 
-    hP = intersect_sum / predicted_sum if predicted_sum > 0 else 0
-    hR = intersect_sum / true_sum if true_sum > 0 else 0
+    hP = true_positive / predicted if predicted else 0
+    hR = true_positive / actual if actual else 0
+    hF = (2 * hP * hR) / (hP + hR) if (hP + hR) else 0
 
-    return hP, hR
+    return hP, hR, hF
 
 
 def hierarchical_f_measure(hP, hR, beta=1.0):