ca nojo

user-friendly-metrics.py

@@ -108,10 +108,7 @@ def num_gt_ids(df):
 def calculate(predictions, 
               references, 
               max_iou: float = 0.5,
-              recognition_thresholds: list = [0.3, 0.5, 0.8],
-              namemap = {"num_misses": "fn",
-                         "num_false_positives": "fp",
-                         "num_detections": "tp"}
+              recognition_thresholds: list = [0.3, 0.5, 0.8]
             ):
     
     """Returns the scores"""
@@ -147,12 +144,16 @@ def calculate(predictions,
         acc.update(refs[:,0].astype('int').tolist(), preds[:,0].astype('int').tolist(), C)
 
     mh = mm.metrics.create()
-    summary = mh.compute(acc, metrics=['recall', 'precision', 'num_misses', 'num_false_positives', 'num_detections']).to_dict()
+    summary = mh.compute(acc, metrics=['num_misses', 'num_false_positives', 'num_detections']).to_dict()
 
     df = events_to_df_map(acc.events)
     tr_ratios = track_ratios(df, obj_frequencies(df))
     unique_gt_ids = num_gt_ids(df)
 
+    namemap = {"num_misses": "fn",
+                "num_false_positives": "fp",
+                "num_detections": "tp"}
+    
     for key in list(summary.keys()):
         if key in namemap:
             summary[namemap[key]] = float(summary[key][0])
@@ -164,7 +165,6 @@ def calculate(predictions,
 
     for th in recognition_thresholds:
         recognized = recognition(tr_ratios, th)
-        summary[f'recognition_{th}'] = float(recognition(tr_ratios, th)/unique_gt_ids)
         summary[f'recognized_{th}'] = int(recognized)
     
     return summary
@@ -245,10 +245,55 @@ def calculate_from_payload(payload: dict,
                         filter_range_name = filter_range[0]
                         output[sequence][model][filter][filter_range_name] = calculate(formated_predictions, all_formated_references[filter][filter_range_name], max_iou=max_iou, recognition_thresholds = recognition_thresholds)
 
-    return output
+    global_and_per_sequence_output = {}
+    global_and_per_sequence_output["global"] = per_sequence_to_global(output, recognition_thresholds)
+    global_and_per_sequence_output["per_sequence"] = output
+    
+    return global_and_per_sequence_output
             
+def sum_dicts(dict1, dict2):
+    """
+    Recursively sums the numerical values in two nested dictionaries.
+    """
+    result = {}
+    for key in dict1.keys() | dict2.keys():  # Union of keys from both dictionaries
+        val1 = dict1.get(key, 0)
+        val2 = dict2.get(key, 0)
+        if isinstance(val1, dict) and isinstance(val2, dict):
+            # If both values are dictionaries, recursively sum them
+            result[key] = sum_dicts(val1, val2)
+        elif isinstance(val1, (int, float)) and isinstance(val2, (int, float)):
+            # If both are numbers, sum them
+            result[key] = val1 + val2
+        else:
+            # If only one dictionary has the key, take the non-zero value
+            result[key] = val1 if val1 != 0 else val2
+    return result
 
+def realize_metrics(metrics_dict, 
+                   recognition_thresholds):
+    metrics_dict["precision"] = metrics_dict["tp"]/(metrics_dict["tp"]+metrics_dict["fp"])
+    metrics_dict["recall"] = metrics_dict["tp"]/(metrics_dict["tp"]+metrics_dict["fn"])
+    metrics_dict["f1"] = 2*metrics_dict["precision"]*metrics_dict["recall"]/(metrics_dict["precision"]+metrics_dict["recall"])
 
+    for th in recognition_thresholds:
+        metrics_dict[f"recognition_{th}"] = metrics_dict[f"recognized_{th}"]/metrics_dict["num_gt_ids"]
+        
+    return metrics_dict
+    
+def per_sequence_to_global(metrics_dict, 
+                           recognition_thresholds):
+    global_metrics = {}
+    for sequence in metrics_dict:
+        for model in metrics_dict[sequence]:
+            if model not in global_metrics:
+                global_metrics[model] = metrics_dict[sequence][model]
+            global_metrics[model] = sum_dicts(global_metrics[model], metrics_dict[sequence][model])
+            metrics_dict[sequence][model] = realize_metrics(metrics_dict[sequence][model], 
+                                                            recognition_thresholds)
+    
+    for model in global_metrics:
+        global_metrics[model] = realize_metrics(global_metrics[model], 
+                                                recognition_thresholds)
 
-
-
+    return global_metrics