| import argparse |
| import json |
| import re |
| from collections import defaultdict |
|
|
| from tqdm import tqdm |
|
|
|
|
| DEFAULT_IOU_THRESH = 0.6 |
| CHOICE_SUBTASKS = ("option_letter", "label_text") |
|
|
|
|
| def clean_text(s: str): |
| """Normalize whitespace and common answer prefixes.""" |
| if not isinstance(s, str): |
| return "" |
| s = s.strip() |
| s = s.replace("Answer:", "").replace("answer:", "") |
| s = re.sub(r"[.\n\r]+", "", s) |
| s = re.sub(r"\s+", " ", s) |
| return s.strip() |
|
|
|
|
| def parse_option_letter(text): |
| """Parse a split option-letter answer such as 'B'.""" |
| text = clean_text(text) |
| return text.upper() if re.fullmatch(r"[A-Da-d]", text) else None |
|
|
|
|
| def normalize_label_text(text): |
| """Normalize a split label-text answer.""" |
| return clean_text(text).lower() |
|
|
|
|
| def parse_bbox(bbox_str): |
| """Parse prediction text in 'x,y,w,h' format.""" |
| try: |
| nums = re.findall(r"[-+]?\d*\.?\d+", bbox_str) |
| if len(nums) < 4: |
| return None |
| nums = nums[:4] |
| x, y, w, h = map(float, nums) |
| if w <= 0 or h <= 0: |
| return None |
| return [x, y, w, h] |
| except Exception: |
| return None |
|
|
|
|
| def bbox_iou(box1, box2): |
| """Compute IoU for boxes in [x, y, w, h] format.""" |
| x1_min, y1_min = box1[0], box1[1] |
| x1_max, y1_max = box1[0] + box1[2], box1[1] + box1[3] |
| x2_min, y2_min = box2[0], box2[1] |
| x2_max, y2_max = box2[0] + box2[2], box2[1] + box2[3] |
|
|
| inter_x1 = max(x1_min, x2_min) |
| inter_y1 = max(y1_min, y2_min) |
| inter_x2 = min(x1_max, x2_max) |
| inter_y2 = min(y1_max, y2_max) |
| inter_w = max(0, inter_x2 - inter_x1) |
| inter_h = max(0, inter_y2 - inter_y1) |
| inter_area = inter_w * inter_h |
| area1 = box1[2] * box1[3] |
| area2 = box2[2] * box2[3] |
| union = area1 + area2 - inter_area |
| return inter_area / union if union > 0 else 0.0 |
|
|
|
|
| def is_text_match(gt_text, pred_text): |
| """Apply the lenient text matching rule to a split label-text answer.""" |
| if not gt_text or not pred_text: |
| return False |
|
|
| gt = gt_text.strip().lower() |
| pred = pred_text.strip().lower() |
|
|
| gt = re.sub(r"\b(a|an|the)\b", "", gt) |
| pred = re.sub(r"\b(a|an|the)\b", "", pred) |
|
|
| gt = re.sub(r"[^a-z0-9\s]", " ", gt) |
| pred = re.sub(r"[^a-z0-9\s]", " ", pred) |
| gt = re.sub(r"\s+", " ", gt).strip() |
| pred = re.sub(r"\s+", " ", pred).strip() |
|
|
| gt_tokens = set(gt.split()) |
| pred_tokens = set(pred.split()) |
| overlap = len(gt_tokens & pred_tokens) |
| union = len(gt_tokens | pred_tokens) |
| return overlap / union > 0.8 if union else False |
|
|
|
|
| def group_split_samples(data): |
| choice_groups = {} |
| grounding_items = [] |
| grounding_ids = set() |
|
|
| for item in data: |
| original_id = item.get("original_id") |
| subtask = item.get("subtask") |
| category = item.get("category", "Unknown") |
| if not original_id: |
| raise ValueError("Understanding sample is missing original_id") |
|
|
| if category.lower() == "grounding": |
| if subtask != "grounding": |
| raise ValueError(f"Missing or invalid grounding subtask for {original_id}: {subtask!r}") |
| if original_id in grounding_ids: |
| raise ValueError(f"Duplicate grounding sample for {original_id}") |
| grounding_ids.add(original_id) |
| grounding_items.append(item) |
| continue |
|
|
| if subtask not in CHOICE_SUBTASKS: |
| raise ValueError(f"Missing or invalid understanding QA subtask: {subtask!r}") |
| group = choice_groups.setdefault(original_id, {}) |
| if subtask in group: |
| raise ValueError(f"Duplicate understanding subtask {subtask!r} for {original_id}") |
| group[subtask] = item |
|
|
| required = set(CHOICE_SUBTASKS) |
| for original_id, group in choice_groups.items(): |
| if set(group) != required: |
| raise ValueError(f"Incomplete understanding subtask pair for {original_id}: {sorted(group)}") |
| return choice_groups, grounding_items |
|
|
|
|
| def evaluate(pred_json, iou_thresh=DEFAULT_IOU_THRESH): |
| with open(pred_json, "r", encoding="utf-8") as f: |
| data = json.load(f) |
|
|
| if not data: |
| raise ValueError(f"No samples found in {pred_json}") |
|
|
| choice_groups, grounding_items = group_split_samples(data) |
| category_stats = defaultdict(lambda: {"total": 0, "correct": 0}) |
| mismatch_examples = [] |
|
|
| qa_correct = 0 |
| option_letter_correct = 0 |
| label_text_correct = 0 |
| label_text_exact_correct = 0 |
|
|
| for original_id, pair in tqdm(choice_groups.items(), desc="Evaluating understanding QA pairs"): |
| letter_item = pair["option_letter"] |
| label_item = pair["label_text"] |
| category = letter_item.get("category", "Unknown") |
| if label_item.get("category", "Unknown") != category: |
| raise ValueError(f"Mismatched understanding categories for {original_id}") |
|
|
| gt_letter = parse_option_letter(letter_item["conversations"][1]["value"]) |
| pred_letter = parse_option_letter(letter_item.get("model_output", "")) |
| gt_label = label_item["conversations"][1]["value"] |
| pred_label = label_item.get("model_output", "") |
| if gt_letter is None or not normalize_label_text(gt_label): |
| raise ValueError(f"Invalid understanding ground truth for {original_id}") |
|
|
| is_letter_correct = gt_letter == pred_letter |
| is_label_correct = is_text_match(gt_label, pred_label) |
| is_label_exact = normalize_label_text(gt_label) == normalize_label_text(pred_label) |
| is_joint_correct = is_letter_correct and is_label_correct |
|
|
| category_stats[category]["total"] += 1 |
| option_letter_correct += is_letter_correct |
| label_text_correct += is_label_correct |
| label_text_exact_correct += is_label_exact |
| if is_joint_correct: |
| qa_correct += 1 |
| category_stats[category]["correct"] += 1 |
| else: |
| mismatch_examples.append({ |
| "original_id": original_id, |
| "image": letter_item["image"], |
| "category": category, |
| "gt": { |
| "option_letter": gt_letter, |
| "label_text": gt_label, |
| }, |
| "pred": { |
| "option_letter": pred_letter, |
| "label_text": pred_label, |
| }, |
| "model_output": { |
| "option_letter": letter_item.get("model_output", ""), |
| "label_text": pred_label, |
| }, |
| }) |
|
|
| correct_gd = 0 |
| iou_sum = 0.0 |
| for item in tqdm(grounding_items, desc="Evaluating understanding grounding"): |
| category = item.get("category", "Grounding") |
| gt_bbox = item.get("gt_bbox", {}) |
| try: |
| gt_box = [gt_bbox["x"], gt_bbox["y"], gt_bbox["w"], gt_bbox["h"]] |
| except (KeyError, TypeError) as exc: |
| raise ValueError(f"Invalid grounding ground truth for {item['original_id']}") from exc |
| pred_raw = item.get("model_output", "") |
| pred_box = parse_bbox(pred_raw) |
|
|
| category_stats[category]["total"] += 1 |
| if pred_box is not None: |
| iou = bbox_iou(pred_box, gt_box) |
| iou_sum += iou |
| if iou >= iou_thresh: |
| correct_gd += 1 |
| category_stats[category]["correct"] += 1 |
| else: |
| mismatch_examples.append({ |
| "original_id": item["original_id"], |
| "image": item["image"], |
| "category": category, |
| "gt_bbox": gt_box, |
| "pred_bbox": pred_box, |
| "iou": round(iou, 3), |
| }) |
| else: |
| mismatch_examples.append({ |
| "original_id": item["original_id"], |
| "image": item["image"], |
| "category": category, |
| "gt_bbox": gt_box, |
| "pred_bbox": "Invalid", |
| "iou": 0.0, |
| }) |
|
|
| qa_total = len(choice_groups) |
| gd_total = len(grounding_items) |
| qa_acc = qa_correct / qa_total * 100 if qa_total else 0.0 |
| option_letter_acc = option_letter_correct / qa_total * 100 if qa_total else 0.0 |
| label_text_acc = label_text_correct / qa_total * 100 if qa_total else 0.0 |
| label_text_exact_acc = label_text_exact_correct / qa_total * 100 if qa_total else 0.0 |
| gd_acc = correct_gd / gd_total * 100 if gd_total else 0.0 |
| avg_iou = iou_sum / gd_total if gd_total else 0.0 |
|
|
| print("\n========== QA Part ==========") |
| print(f"Inference samples: {qa_total * 2}") |
| print(f"Original questions: {qa_total}") |
| print(f"Overall accuracy (option_letter + label_text): {qa_acc:.2f}%") |
| print(f"Option-letter accuracy: {option_letter_acc:.2f}%") |
| print(f"Label-text soft-match accuracy: {label_text_acc:.2f}%") |
| print(f"Label-text exact accuracy: {label_text_exact_acc:.2f}%") |
|
|
| print("\n========== Grounding Part ==========") |
| print(f"Samples: {gd_total}") |
| print(f"Accuracy (IoU >= {iou_thresh}): {gd_acc:.2f}%") |
| print(f"Average IoU: {avg_iou:.3f}") |
|
|
| print("\nCategory-wise Accuracy:") |
| category_acc = {} |
| for category, stats in category_stats.items(): |
| acc = stats["correct"] / stats["total"] * 100 if stats["total"] else 0.0 |
| category_acc[category] = { |
| "total": stats["total"], |
| "correct": stats["correct"], |
| "accuracy (%)": round(acc, 2), |
| } |
| print(f" {category:20s}: {acc:5.2f}% ({stats['correct']}/{stats['total']})") |
|
|
| result_summary = { |
| "qa": { |
| "inference_samples": qa_total * 2, |
| "total": qa_total, |
| "correct": qa_correct, |
| "accuracy (%)": round(qa_acc, 2), |
| "option_letter_accuracy (%)": round(option_letter_acc, 2), |
| "label_text_accuracy (%)": round(label_text_acc, 2), |
| "label_text_exact_accuracy (%)": round(label_text_exact_acc, 2), |
| }, |
| "grounding": { |
| "total": gd_total, |
| "correct": correct_gd, |
| "accuracy (%)": round(gd_acc, 2), |
| "average_iou": round(avg_iou, 3), |
| "iou_threshold": iou_thresh, |
| }, |
| "categories": category_acc, |
| } |
|
|
| error_path = pred_json.replace(".json", "_errors.json") |
| with open(error_path, "w", encoding="utf-8") as f: |
| json.dump(mismatch_examples, f, indent=2, ensure_ascii=False) |
|
|
| result_path = pred_json.replace(".json", "_accuracy.json") |
| with open(result_path, "w", encoding="utf-8") as f: |
| json.dump(result_summary, f, indent=2, ensure_ascii=False) |
|
|
| print(f"\nError samples saved to {error_path}") |
| print(f"Accuracy summary saved to {result_path}") |
| return result_summary |
|
|
|
|
| def parse_args(): |
| parser = argparse.ArgumentParser(description="Evaluate split EventDrive understanding predictions.") |
| parser.add_argument("--pred-json", required=True, help="Path to split understanding JSON with model_output fields.") |
| parser.add_argument("--iou-thresh", type=float, default=DEFAULT_IOU_THRESH, help="IoU threshold for grounding.") |
| return parser.parse_args() |
|
|
|
|
| if __name__ == "__main__": |
| args = parse_args() |
| evaluate(args.pred_json, iou_thresh=args.iou_thresh) |
|
|
