| import json |
| import sys |
| import re |
| import pandas as pd |
| import numpy as np |
|
|
|
|
| def parse_jsonl(file_name): |
| with open(file_name, 'r', encoding='utf-8') as f: |
| lines = f.readlines() |
| return [json.loads(line) for line in lines] |
|
|
|
|
| def unwrap_answer(data): |
| if isinstance(data, dict) and "answer" in data: |
| return data["answer"] |
| return data |
|
|
|
|
| def extract_json_content(text): |
| if not text: |
| return None |
| |
| text = text.strip() |
| start = text.find('{') |
| end = text.rfind('}') + 1 |
| if start == -1 or end <= start: |
| return None |
|
|
| try: |
| return json.loads(text[start:end]) |
| except json.JSONDecodeError: |
| return None |
|
|
|
|
| def normalize_val(val): |
| if val is None: |
| return "" |
| s = re.sub(r"[<>]", "", str(val)).strip() |
| if not s: |
| return "" |
| num_candidate = s.replace(",", "") |
| try: |
| num = float(num_candidate) |
| except ValueError: |
| return s |
| return str(int(num)) if num.is_integer() else str(num) |
|
|
|
|
| def flatten_json(data, prefix=""): |
| items = set() |
| if isinstance(data, dict): |
| for k, v in data.items(): |
| items.update(flatten_json(v, f"{prefix}.{k}" if prefix else k)) |
| elif isinstance(data, list): |
| for v in data: |
| if isinstance(v, list): |
| row_tuple = tuple(normalize_val(sub_item) for sub_item in v) |
| items.add((prefix, row_tuple)) |
| else: |
| items.update(flatten_json(v, prefix)) |
| else: |
| s = normalize_val(data) |
| parts = re.split(r'[，,]', s) |
| for part in parts: |
| part = part.strip() |
| if part: |
| items.add((prefix, part)) |
| return items |
|
|
|
|
| def calculate_metrics(pred_json, gt_json, doc_id=None): |
| def filter_present_categories(obj): |
| return {"present_categories": obj.get("present_categories", [])} if isinstance(obj, dict) else {} |
|
|
| if doc_id and doc_id.startswith("DTR_003"): |
| pred_json = filter_present_categories(pred_json) |
| gt_json = filter_present_categories(gt_json) |
|
|
| if doc_id and (doc_id.startswith("NC_001") or doc_id.startswith("NC_002")): |
| if pred_json is None: |
| return None |
| try: |
| return 1.0 if abs(float(pred_json) - float(gt_json)) <= 2 else 0.0 |
| except Exception: |
| return 0.0 |
|
|
| pred_set = flatten_json(pred_json) if pred_json is not None else set() |
| gt_set = flatten_json(gt_json) |
|
|
| if not gt_set: |
| return 1.0 if not pred_set else 0.0 |
|
|
| tp = len(pred_set & gt_set) |
| fp = len(pred_set) - tp |
| fn = len(gt_set) - tp |
|
|
| precision = tp / (tp + fp) if (tp + fp) else 0.0 |
| recall = tp / (tp + fn) if (tp + fn) else 0.0 |
| f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) else 0.0 |
| return f1 |
|
|
|
|
| def evaluate_samples(pred_file, gt_file): |
| predictions = parse_jsonl(pred_file) |
| gts = parse_jsonl(gt_file) |
| gt_map = {gt['id']: gt for gt in gts} |
| raw_scores = [] |
| for pred_data in predictions: |
| doc_id = pred_data['id'] |
| |
| if doc_id.startswith('NC_005'): |
| continue |
| pred_json = extract_json_content(pred_data['response']) |
| gt_json = json.loads(gt_map[doc_id]['response']) |
| pred_json = unwrap_answer(pred_json) |
| gt_json = unwrap_answer(gt_json) |
| |
| f1 = calculate_metrics(pred_json, gt_json, doc_id) |
| raw_score = { |
| "id": doc_id, |
| "task": gt_map[doc_id]['task'], |
| "subtask": gt_map[doc_id]['subtask'], |
| "robustness": gt_map[doc_id]['robustness'], |
| "f1": f1 |
| } |
| raw_scores.append(raw_score) |
| return raw_scores |
|
|
|
|
| def evaluate_tasks(raw_scores): |
| df = pd.DataFrame(raw_scores) |
| subtask_mean = ( |
| df.groupby(["task", "subtask"], as_index=False) |
| .agg(subtask_f1_mean=("f1", "mean")) |
| ) |
| task_mean = ( |
| subtask_mean.groupby("task", as_index=False) |
| .agg(task_f1=("subtask_f1_mean", "mean")) |
| ) |
| order = ["DTR", "KIE", "IQE", "CC", "VC", "NC", "RR"] |
| task_mean_sorted = ( |
| task_mean.assign(task=pd.Categorical(task_mean["task"], categories=order, ordered=True)) |
| .sort_values("task") |
| .reset_index(drop=True) |
| ) |
| print("Performance by Task:\n", task_mean_sorted) |
|
|
|
|
| def evaluate_robustness(raw_scores): |
| df = pd.DataFrame(raw_scores) |
| subtask_mean = ( |
| df.loc[df["task"].ne("IQE")] |
| .groupby(["robustness", "task", "subtask"], as_index=False) |
| .agg(subtask_f1_mean=("f1", "mean")) |
| ) |
| normal_sub_mean = ( |
| subtask_mean[subtask_mean["robustness"].eq("Normal Captures")] |
| ) |
| normal_task_mean = ( |
| normal_sub_mean.groupby("task", as_index=False) |
| .agg(task_f1=("subtask_f1_mean", "mean")) |
| ) |
| normal_overall_mean = normal_task_mean["task_f1"].mean() |
|
|
| sec_keys = ( |
| subtask_mean.loc[subtask_mean["robustness"].eq("Secondary Captures"), ["task", "subtask"]] |
| .drop_duplicates() |
| ) |
| sec_normal_sub_mean = ( |
| subtask_mean[subtask_mean["robustness"].eq("Normal Captures")] |
| .merge(sec_keys, on=["task", "subtask"], how="inner") |
| ) |
| sec_normal_task_mean = ( |
| sec_normal_sub_mean.groupby("task", as_index=False) |
| .agg(task_f1=("subtask_f1_mean", "mean")) |
| ) |
| sec_normal_overall_mean = sec_normal_task_mean["task_f1"].mean() |
| |
| multi_subtask_mean = ( |
| df.loc[df["subtask"].isin([ |
| "DTR_001_001", |
| "DTR_003_001", |
| "KIE_002_001", |
| ])] |
| .groupby(["robustness", "task", "subtask"], as_index=False) |
| .agg(subtask_f1_mean=("f1", "mean")) |
| ) |
|
|
| multi_normal_sub_mean = ( |
| multi_subtask_mean[multi_subtask_mean["robustness"].eq("Normal Captures")] |
| ) |
| multi_normal_task_mean = ( |
| multi_normal_sub_mean.groupby("task", as_index=False) |
| .agg(task_f1=("subtask_f1_mean", "mean")) |
| ) |
| multi_normal_overall_mean = multi_normal_task_mean["task_f1"].mean() |
|
|
| task_mean = ( |
| subtask_mean.groupby(["robustness", "task"], as_index=False) |
| .agg(task_f1=("subtask_f1_mean", "mean")) |
| ) |
| robustness_scores = ( |
| task_mean.groupby("robustness", as_index=False) |
| .agg(robustness_macro_f1=("task_f1", "mean")) |
| .sort_values("robustness_macro_f1", ascending=False) |
| .reset_index(drop=True) |
| ) |
| use_special_denoms = { |
| "Secondary Captures": sec_normal_overall_mean, |
| "Cluttered Background": sec_normal_overall_mean, |
| "Multi-doc Images": multi_normal_overall_mean} |
| robustness_scores = robustness_scores.copy() |
| robustness_scores["normal_denom"] = robustness_scores["robustness"].apply( |
| lambda r: use_special_denoms.get(r, normal_overall_mean) |
| ) |
| robustness_scores["relative_to_normal"] = ( |
| robustness_scores["robustness_macro_f1"] / robustness_scores["normal_denom"].replace(0, np.nan) |
| ) |
| robustness_scores = robustness_scores.drop(columns=["normal_denom", "robustness_macro_f1"]) |
| robustness_scores = robustness_scores.sort_values('relative_to_normal', ascending=False) |
| print("Performance by Robustness:\n", robustness_scores) |
|
|
|
|
| if __name__ == "__main__": |
| p_file = sys.argv[1] |
| g_file = sys.argv[2] |
| raw_scores = evaluate_samples(p_file, g_file) |
| evaluate_tasks(raw_scores) |
| evaluate_robustness(raw_scores) |
|
|
