| |
| |
|
|
| import argparse |
| import json |
| import os |
| import re |
| import unicodedata |
| from collections import defaultdict |
| from typing import Any, Dict, List, Tuple |
|
|
| |
| _PUNCT_MAP = str.maketrans("。、“”‘’（）【】", ".,\"\"''()[]") |
|
|
| def norm_text(s: Any) -> str: |
| if not s: return "" |
| t = str(s) |
| t = unicodedata.normalize('NFKC', t) |
| t = t.translate(_PUNCT_MAP) |
| t = re.sub(r'[\u200b\u200c\u200d\ufeff]+', '', t) |
| return re.sub(r'\s+', ' ', t).strip() |
|
|
| |
| def levenshtein(a: str, b: str) -> int: |
| if a == b: return 0 |
| la, lb = len(a), len(b) |
| if la == 0: return lb |
| if lb == 0: return la |
| if la < lb: a, b, la, lb = b, a, lb, la |
| prev = list(range(lb + 1)) |
| cur = [0] * (lb + 1) |
| for i in range(1, la + 1): |
| cur[0] = i |
| ca = a[i - 1] |
| for j in range(1, lb + 1): |
| cost = 0 if ca == b[j - 1] else 1 |
| cur[j] = min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost) |
| prev, cur = cur, prev |
| return prev[lb] |
|
|
| def iou_xyxy(a: List[float], b: List[float]) -> float: |
| ax1, ay1, ax2, ay2 = float(a[0]), float(a[1]), float(a[2]), float(a[3]) |
| bx1, by1, bx2, by2 = float(b[0]), float(b[1]), float(b[2]), float(b[3]) |
| ix1, iy1 = max(ax1, bx1), max(ay1, by1) |
| ix2, iy2 = min(ax2, bx2), min(ay2, by2) |
| iw, ih = max(0, ix2 - ix1), max(0, iy2 - iy1) |
| inter = iw * ih |
| if inter <= 0: return 0.0 |
| union = max(0, ax2 - ax1) * max(0, ay2 - ay1) + max(0, bx2 - bx1) * max(0, by2 - by1) - inter |
| return inter / union if union > 0 else 0.0 |
|
|
| def greedy_match_iou(preds: List[List[float]], gts: List[List[float]], thr: float) -> Tuple[int, int, int]: |
| pairs = [] |
| for i, pb in enumerate(preds): |
| for j, gb in enumerate(gts): |
| v = iou_xyxy(pb, gb) |
| if v >= thr: pairs.append((v, i, j)) |
| pairs.sort(key=lambda x: x[0], reverse=True) |
| used_p, used_g = set(), set() |
| tp = 0 |
| for v, i, j in pairs: |
| if i in used_p or j in used_g: continue |
| used_p.add(i); used_g.add(j) |
| tp += 1 |
| return tp, max(0, len(preds) - tp), max(0, len(gts) - tp) |
|
|
| |
| def _extract_json_string(s: str) -> str: |
| m = re.search(r"```(?:json)?\s*([\s\S]*?)```", s) |
| return m.group(1).strip() if m else s.strip() |
|
|
| def parse_pred_text_for_r2t(raw: str) -> Tuple[str, bool]: |
| if not raw or not isinstance(raw, str): return "", False |
| raw_str = _extract_json_string(raw) |
| |
| |
| if raw_str.strip() in ("[]", "{}", '""', "''"): |
| return "", True |
| |
| try: |
| obj = json.loads(raw_str) |
| while isinstance(obj, list) and len(obj) == 1: obj = obj[0] |
| if isinstance(obj, list) and len(obj) == 0: return "", True |
| if isinstance(obj, dict) and "text" in obj: return str(obj["text"]), True |
| if isinstance(obj, list) and obj and isinstance(obj[0], dict) and "text" in obj[0]: return str(obj[0]["text"]), True |
| if isinstance(obj, str): return obj, True |
| except Exception: |
| pass |
| |
| m = re.search(r'"text"\s*:\s*(?:\[\s*)?(["\'])(.*?)(?:\1|(?=\})|(?=$))', raw_str, flags=re.DOTALL) |
| if m: return str(m.group(2)), True |
| return raw_str.strip(), False |
|
|
| def parse_bbox_list_from_t2r(raw: str) -> Tuple[List[List[float]], bool]: |
| if not raw or not isinstance(raw, str): return [], False |
| raw_str = _extract_json_string(raw) |
| |
| if raw_str.strip() in ("[]", "{}", '""', "''"): |
| return [], True |
| |
| out = [] |
| is_valid = False |
| try: |
| obj = json.loads(raw_str) |
| is_valid = True |
| while isinstance(obj, list) and len(obj) == 1: obj = obj[0] |
| if isinstance(obj, dict): |
| b = obj.get("bbox") or obj.get("bbox_2d") or obj.get("xyxy") or obj.get("box") |
| if b and len(b) >= 4: out.append([float(x) for x in b[:4]]) |
| elif isinstance(obj, list): |
| if len(obj) == 0: return [], True |
| for item in obj: |
| if isinstance(item, (list, tuple)) and len(item) >= 4: |
| out.append([float(x) for x in item[:4]]) |
| elif isinstance(item, dict): |
| b = item.get("bbox") or item.get("bbox_2d") or item.get("xyxy") or item.get("box") |
| if b and len(b) >= 4: out.append([float(x) for x in b[:4]]) |
| if out: return out, True |
| except Exception: |
| pass |
| |
| boxes = re.findall(r'(?:"bbox_2d"|"bbox"|"xyxy"|"box")\s*:\s*\[\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\]', raw_str) |
| if boxes: |
| out = [[float(x) for x in b] for b in boxes] |
| return out, True |
| |
| return [], is_valid |
|
|
| |
| def eval_r2t(rows: List[dict]) -> Tuple[dict, dict, List[dict]]: |
| n = exact = ed_leq1 = sum_ed = sum_len = macro_sum = macro_n = parse_errors = 0 |
| per_sample = [] |
| cat_stats = defaultdict(lambda: {"n": 0, "exact": 0, "sum_ed": 0, "sum_len": 0, "parse_errors": 0}) |
| |
| for idx, r in enumerate(rows): |
| gt = norm_text(r.get("GT") or r.get("answer") or "") |
| pred_raw, is_valid = parse_pred_text_for_r2t(r.get("model_answer") or "") |
| pred = norm_text(pred_raw) |
| cat = r.get("category", "unknown") |
| |
| n += 1 |
| if not is_valid: |
| parse_errors += 1 |
| cat_stats[cat]["parse_errors"] += 1 |
| |
| ed = levenshtein(pred, gt) |
| exact_i = 1 if pred == gt else 0 |
| ed_leq1_i = 1 if ed <= 1 else 0 |
| |
| exact += exact_i; ed_leq1 += ed_leq1_i |
| sum_ed += ed; sum_len += len(gt) |
| macro = (ed / len(gt)) if len(gt) > 0 else (0.0 if len(pred) == 0 else 1.0) |
| macro_sum += macro; macro_n += 1 |
| |
| cat_stats[cat]["n"] += 1 |
| cat_stats[cat]["exact"] += exact_i |
| cat_stats[cat]["sum_ed"] += ed |
| cat_stats[cat]["sum_len"] += len(gt) |
| |
| per_sample.append({ |
| "idx": idx, "image_path": r.get("image_path"), "category": cat, |
| "GT_text": gt, "parsed_pred_text": pred_raw, "parse_success": is_valid, |
| "exact": exact_i, "ed": ed, "cer": round(macro, 6), "acc_ed_leq_1": ed_leq1_i, |
| }) |
| |
| summary = { |
| "count": n, "parse_error_rate": round(parse_errors / n, 6) if n else 0.0, |
| "exact_acc": round(exact / n, 6) if n else 0.0, |
| "cer_micro": round(sum_ed / sum_len, 6) if sum_len > 0 else 0.0, |
| "cer_macro": round(macro_sum / macro_n, 6) if macro_n > 0 else 0.0, |
| } |
| cat_summary = {k: { |
| "count": v["n"], "parse_error_rate": round(v["parse_errors"] / v["n"], 6) if v["n"] else 0.0, |
| "exact_acc": round(v["exact"] / v["n"], 6) if v["n"] else 0.0, |
| "cer_micro": round(v["sum_ed"] / v["sum_len"], 6) if v["sum_len"] else 0.0 |
| } for k, v in cat_stats.items()} |
| |
| return summary, cat_summary, per_sample |
|
|
| def eval_t2r(rows: List[dict], iou_thr: float = 0.5, ks: Tuple[int, ...] = (1, 3)) -> Tuple[dict, dict, List[dict]]: |
| clusters_total = TP = FP = FN = parse_errors = 0 |
| qsr_hits = {k: 0 for k in ks} |
| per_sample = [] |
| cat_stats = defaultdict(lambda: {"clusters": 0, "tp": 0, "fp": 0, "fn": 0, "parse_errors": 0}) |
| |
| for idx, r in enumerate(rows): |
| gt_bboxes_raw = r.get("bbox") |
| gts = [] |
| if isinstance(gt_bboxes_raw, list): |
| if gt_bboxes_raw and isinstance(gt_bboxes_raw[0], (list, tuple)): |
| gts = [[float(x) for x in b[:4]] for b in gt_bboxes_raw if len(b) >= 4] |
| elif len(gt_bboxes_raw) >= 4: |
| gts = [[float(x) for x in gt_bboxes_raw[:4]]] |
| |
| pred_boxes_raw, is_valid = parse_bbox_list_from_t2r(r.get("model_answer") or "") |
| valid_pred_boxes = [b for b in pred_boxes_raw if len(b) == 4 and b[2] > b[0] and b[3] > b[1]] |
| cat = r.get("category", "unknown") |
| |
| clusters_total += 1 |
| if not is_valid: |
| parse_errors += 1 |
| cat_stats[cat]["parse_errors"] += 1 |
| |
| qsr_at_k = {} |
| for k in ks: |
| top = valid_pred_boxes[:k] |
| hit = any(any(iou_xyxy(pb, gb) >= iou_thr for gb in gts) for pb in top) |
| qsr_at_k[k] = 1 if hit else 0 |
| if hit: qsr_hits[k] += 1 |
| |
| tp, fp, fn = greedy_match_iou(valid_pred_boxes, gts, thr=iou_thr) |
| TP += tp; FP += fp; FN += fn |
| |
| cat_stats[cat]["clusters"] += 1 |
| cat_stats[cat]["tp"] += tp; cat_stats[cat]["fp"] += fp; cat_stats[cat]["fn"] += fn |
| |
| prec_i = tp / (tp + fp) if (tp + fp) > 0 else 0.0 |
| rec_i = tp / (tp + fn) if (tp + fn) > 0 else 0.0 |
| |
| per_sample.append({ |
| "idx": idx, "image_path": r.get("image_path"), "category": cat, |
| "GT_boxes": gts, "parsed_pred_boxes": valid_pred_boxes, "parse_success": is_valid, |
| "qsr_at_1": qsr_at_k.get(1, 0), "qsr_at_3": qsr_at_k.get(3, 0), |
| "precision": round(prec_i, 6), "recall": round(rec_i, 6), |
| }) |
| |
| precision = TP / (TP + FP) if (TP + FP) > 0 else 0.0 |
| recall = TP / (TP + FN) if (TP + FN) > 0 else 0.0 |
| f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0 |
| |
| summary = { |
| "clusters_total": clusters_total, "iou_thr": iou_thr, "parse_error_rate": round(parse_errors / clusters_total, 6) if clusters_total else 0.0, |
| "qsr": {f"QSR@{k}": round(qsr_hits[k] / clusters_total, 6) if clusters_total else 0.0 for k in ks}, |
| "precision": round(precision, 6), "recall": round(recall, 6), "f1": round(f1, 6), |
| } |
| cat_summary = {} |
| for k, v in cat_stats.items(): |
| c_p = v["tp"] / (v["tp"] + v["fp"]) if (v["tp"] + v["fp"]) > 0 else 0.0 |
| c_r = v["tp"] / (v["tp"] + v["fn"]) if (v["tp"] + v["fn"]) > 0 else 0.0 |
| cat_summary[k] = { |
| "clusters": v["clusters"], "parse_error_rate": round(v["parse_errors"] / v["clusters"], 6) if v["clusters"] else 0.0, |
| "precision": round(c_p, 6), "recall": round(c_r, 6) |
| } |
| |
| return summary, cat_summary, per_sample |
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--pred", "-p", default="infer_output/TA-Bench-abs_with_predictions.jsonl") |
| ap.add_argument("--iou-thr", type=float, default=0.5) |
| ap.add_argument("--export-jsonl", default="case_analysis.jsonl", help="Export per-sample evaluation results") |
| ap.add_argument("--output", default=None, help="Export summary report") |
| args = ap.parse_args() |
|
|
| if not os.path.isfile(args.pred): |
| print(f"File not found: {args.pred}") |
| return |
|
|
| rows = [] |
| with open(args.pred, "r", encoding="utf-8") as f: |
| for line in f: |
| if line.strip(): rows.append(json.loads(line)) |
| |
| r2t_rows = [r for r in rows if r.get("task_type") == "R2T"] |
| t2r_rows = [r for r in rows if r.get("task_type") == "T2R"] |
| ks = (1, 3) |
|
|
| r2t_sum, r2t_cat, r2t_per = eval_r2t(r2t_rows) if r2t_rows else ({}, {}, []) |
| t2r_sum, t2r_cat, t2r_per = eval_t2r(t2r_rows, args.iou_thr, ks) if t2r_rows else ({}, {}, []) |
|
|
| |
| r2t_acc = r2t_sum.get("exact_acc", 0.0) |
| t2r_f1 = t2r_sum.get("f1", 0.0) |
| overall = 0.5 * r2t_acc + 0.5 * t2r_f1 |
|
|
| report = { |
| "Overall_Score": round(overall, 6), |
| "R2T_Accuracy": round(r2t_acc, 6), |
| "T2R_F1_Score": round(t2r_f1, 6), |
| "R2T_Details": r2t_sum, |
| "T2R_Details": t2r_sum, |
| "R2T_Category": r2t_cat, |
| "T2R_Category": t2r_cat |
| } |
| |
| print("=" * 40) |
| print(f"R2T Accuracy: {round(r2t_acc, 6)}") |
| print(f"T2R F1 Score: {round(t2r_f1, 6)}") |
| print(f"Overall Score (0.5*R2T + 0.5*T2R): {round(overall, 6)}") |
| print("=" * 40) |
| print(json.dumps(report, ensure_ascii=False, indent=2)) |
| |
| if args.output: |
| with open(args.output, "w", encoding="utf-8") as f: |
| json.dump(report, f, ensure_ascii=False, indent=2) |
| print(f"\n✅ Report exported to {args.output}") |
|
|
| if args.export_jsonl: |
| with open(args.export_jsonl, "w", encoding="utf-8") as f: |
| for typ, per in [("R2T", r2t_per), ("T2R", t2r_per)]: |
| for s in per: |
| f.write(json.dumps({"task_type": typ, **s}, ensure_ascii=False) + "\n") |
| print(f"\n✅ All cases exported to {args.export_jsonl}") |
|
|
| if __name__ == "__main__": |
| main() |
|
|
