Upload 5 files

README.md

@@ -0,0 +1,165 @@
+---
+pretty_name: EventDrive
+language:
+- en
+---
+
+# EventDrive
+
+## EventDrive: Event Cameras for Vision-Language Driving Intelligence
+
+Dongyue Lu, Rong Li, Ao Liang, Lingdong Kong, Wei Yin, Lai Xing Ng, Benoit R. Cottereau, Camille Simon Chane, and Wei Tsang Ooi
+
+**CVPR 2026**
+
+[Project Page](https://dylanorange.github.io/projects/eventdrive/) | [Paper](https://dylanorange.github.io/projects/eventdrive/static/files/EventDrive.pdf) | [Dataset](https://huggingface.co/datasets/dylanorange/EventDrive)
+
+EventDrive is a unified event-frame driving benchmark for vision-language driving intelligence. It combines synchronized RGB frames, event-camera data, and instruction-style annotations to study how event sensing supports multimodal perception, reasoning, prediction, and planning under diverse driving conditions.
+
+The benchmark covers four dimensions:
+
+- **Perception**: scene-level driving perception questions.
+- **Understanding**: object awareness, grounding, appearance, status, and spatial-relation questions.
+- **Prediction**: short-term behavior prediction for a highlighted dynamic agent.
+- **Planning**: high-level driving intent and ego-trajectory prediction.
+
+## Repository Layout
+
+```text
+.
+├── eventdrive_perception.tar.gz
+├── eventdrive_understanding.tar.gz
+├── eventdrive_prediction.tar.gz
+├── eventdrive_planning.tar.gz
+├── json/
+│   ├── perception/
+│   │   ├── dsec/
+│   │   ├── m3ed/
+│   │   └── pku/
+│   ├── understanding/
+│   ├── prediction/
+│   └── planning/
+└── scripts/
+    ├── evaluation_perception.py
+    ├── evaluation_understanding.py
+    ├── evaluation_prediction.py
+    └── evaluation_planning.py
+```
+
+Create a `data/` directory and extract all archives from the repository root:
+
+```bash
+mkdir -p data
+tar -xzf eventdrive_perception.tar.gz -C data
+tar -xzf eventdrive_understanding.tar.gz -C data
+tar -xzf eventdrive_prediction.tar.gz -C data
+tar -xzf eventdrive_planning.tar.gz -C data
+```
+
+The extracted data follows this structure:
+
+```text
+data/
+├── perception/
+│   ├── dsec/
+│   │   ├── train/<sequence>/{image,event}/
+│   │   └── test/<sequence>/{image,event}/
+│   ├── m3ed/<sequence>/{image,event}/
+│   └── pku/aps_frames_sampled/val/<condition>/<sequence>/
+├── understanding/
+│   ├── train/<sequence>/{image,event}/
+│   └── test/<sequence>/{image,event}/
+├── prediction/<sequence>/{image,event}/
+└── planning/<sequence>/{image,event}/
+```
+
+Each `image/` directory contains RGB frames. Each `event/` directory contains the paired event-camera representation in `.npz` format.
+
+For PKU perception data, paired `.png` and `.npz` files are stored side by side in each sequence directory instead of separate `image/` and `event/` directories.
+
+## Annotation Files
+
+All annotation paths are relative to the repository root and start with `data/`. Run the scripts from the repository root after extracting the archives.
+
+Each dimension provides train and test annotations. Files ending in `_hard.json` contain the hard test subsets.
+
+The released annotations under `json/` use separate prompts for answer components such as option letter and label text, or speed and path intent. Samples originating from the same question share an `original_id`. The evaluation scripts use this field to pair component predictions before computing joint accuracy. Planning trajectory samples are evaluated independently and do not require an `original_id`.
+
+A typical annotation includes paired image and event paths plus an instruction-answer conversation:
+
+```json
+{
+  "image": "data/perception/dsec/test/interlaken_00_a/image/000005.png",
+  "event": "data/perception/dsec/test/interlaken_00_a/event/000005.npz",
+  "category": "Scene type",
+  "original_id": "perception/dsec/dsec_test_perception.json:000000",
+  "subtask": "option_letter",
+  "conversations": [
+    {
+      "from": "human",
+      "value": "<instruction>"
+    },
+    {
+      "from": "gpt",
+      "value": "<ground-truth answer>"
+    }
+  ]
+}
+```
+
+Add a `model_output` field to each sample after inference:
+
+```json
+{
+  "model_output": "<model prediction>"
+}
+```
+
+For understanding grounding samples, boxes use `[x, y, w, h]`, where `(x, y)` is the top-left corner and `(w, h)` is the width and height.
+
+## Evaluation
+
+Install the evaluation dependencies:
+
+```bash
+pip install numpy tqdm
+```
+
+Run the matching evaluator on an inference result JSON file generated from the annotations under `json/`:
+
+```bash
+python scripts/evaluation_perception.py \
+  --pred-json results/dsec_test_perception.json
+
+python scripts/evaluation_understanding.py \
+  --pred-json results/dsec_test_understanding.json \
+  --iou-thresh 0.6
+
+python scripts/evaluation_prediction.py \
+  --pred-json results/m3ed_test_prediction.json
+
+python scripts/evaluation_planning.py \
+  --pred-json results/m3ed_test_planning.json
+```
+
+The evaluators write summary JSON files next to the prediction file. They also save mismatch examples for debugging when applicable.
+
+Metrics:
+
+- **Perception**: joint accuracy after pairing the split option-letter and label-text answers. Both answers must be correct.
+- **Understanding**: joint QA accuracy after pairing the split option-letter and label-text answers, category-wise accuracy, grounding accuracy at the selected IoU threshold, and mean IoU. Both QA answers must be correct. The default IoU threshold is `0.6`.
+- **Prediction**: speed accuracy, path accuracy, class-wise accuracy, and joint speed-path accuracy after pairing split answers.
+- **Planning**: high-level speed accuracy, path accuracy, class-wise accuracy, joint speed-path accuracy after pairing split answers, and trajectory L2 error at `1s`, `3s`, and `5s`.
+
+Planning trajectory predictions must contain exactly 10 `[x, y]` waypoints at 0.5-second intervals. Evaluation terminates with an error if a trajectory prediction does not follow this format.
+
+## Citation
+
+```bibtex
+@InProceedings{Lu_2026_CVPR,
+  author    = {Lu, Dongyue and Li, Rong and Liang, Ao and Kong, Lingdong and Yin, Wei and Ng, Lai Xing and Cottereau, Benoit R. and Chane, Camille Simon and Ooi, Wei Tsang},
+  title     = {EventDrive: Event Cameras for Vision-Language Driving Intelligence},
+  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
+  year      = {2026},
+}
+```

scripts/evaluation_perception.py

@@ -0,0 +1,168 @@
+import argparse
+import json
+import re
+from collections import defaultdict
+
+from tqdm import tqdm
+
+
+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 such as 'Low light'."""
+    return clean_text(text).lower()
+
+
+def group_split_choices(data):
+    groups = {}
+    for item in data:
+        original_id = item.get("original_id")
+        subtask = item.get("subtask")
+        if not original_id:
+            raise ValueError("Perception sample is missing original_id")
+        if subtask not in CHOICE_SUBTASKS:
+            raise ValueError(f"Missing or invalid perception subtask: {subtask!r}")
+
+        group = groups.setdefault(original_id, {})
+        if subtask in group:
+            raise ValueError(f"Duplicate perception subtask {subtask!r} for {original_id}")
+        group[subtask] = item
+
+    required = set(CHOICE_SUBTASKS)
+    for original_id, group in groups.items():
+        if set(group) != required:
+            raise ValueError(f"Incomplete perception subtask pair for {original_id}: {sorted(group)}")
+    return groups
+
+
+def evaluate(pred_json):
+    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}")
+
+    groups = group_split_choices(data)
+    total, correct = 0, 0
+    option_letter_correct, label_text_correct = 0, 0
+    mismatch_examples = []
+    category_stats = defaultdict(lambda: {"total": 0, "correct": 0})
+
+    for original_id, pair in tqdm(groups.items(), desc="Evaluating perception 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 perception 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 = normalize_label_text(label_item["conversations"][1]["value"])
+        pred_label = normalize_label_text(label_item.get("model_output", ""))
+        if gt_letter is None or not gt_label:
+            raise ValueError(f"Invalid perception ground truth for {original_id}")
+
+        is_letter_correct = gt_letter == pred_letter
+        is_label_correct = gt_label == pred_label
+        is_joint_correct = is_letter_correct and is_label_correct
+
+        total += 1
+        category_stats[category]["total"] += 1
+        option_letter_correct += is_letter_correct
+        label_text_correct += is_label_correct
+        if is_joint_correct:
+            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": label_item.get("model_output", ""),
+                },
+            })
+
+    overall_acc = correct / total * 100
+    option_letter_acc = option_letter_correct / total * 100
+    label_text_acc = label_text_correct / total * 100
+
+    print(f"\nInference samples: {len(data)}")
+    print(f"Original questions: {total}")
+    print(f"Overall accuracy (option_letter + label_text): {overall_acc:.2f}%")
+    print(f"Option-letter accuracy: {option_letter_acc:.2f}%")
+    print(f"Label-text accuracy: {label_text_acc:.2f}%")
+    print(f"Wrong original questions: {len(mismatch_examples)}")
+
+    print("\nCategory-wise Joint 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 = {
+        "overall": {
+            "inference_samples": len(data),
+            "total": total,
+            "correct": correct,
+            "accuracy (%)": round(overall_acc, 2),
+            "option_letter_accuracy (%)": round(option_letter_acc, 2),
+            "label_text_accuracy (%)": round(label_text_acc, 2),
+        },
+        "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 perception predictions.")
+    parser.add_argument("--pred-json", required=True, help="Path to split perception JSON with model_output fields.")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    evaluate(args.pred_json)

scripts/evaluation_planning.py

@@ -0,0 +1,230 @@
+import argparse
+import json
+import re
+from tqdm import tqdm
+
+
+HIGHLEVEL_CATEGORIES = {
+    "speed": ["KEEP", "ACCELERATE", "DECELERATE", "STOP"],
+    "path": ["STRAIGHT", "LEFT_TURN", "RIGHT_TURN", "LEFT_CHANGE", "RIGHT_CHANGE", "UNKNOWN"],
+}
+REQUIRED_HIGHLEVEL_SUBTASKS = set(HIGHLEVEL_CATEGORIES)
+
+
+def get_numpy():
+    import numpy as np
+    return np
+
+
+def clean_text(s: str):
+    if not isinstance(s, str):
+        return ""
+    s = s.strip()
+    s = re.sub(r"[.\n\r]+", " ", s)
+    s = re.sub(r"\s+", " ", s)
+    return s.strip()
+
+
+def parse_highlevel_prediction(text, subtask):
+    if subtask not in HIGHLEVEL_CATEGORIES:
+        raise ValueError(f"Unexpected planning high-level subtask: {subtask!r}")
+
+    text = clean_text(text).upper()
+    categories = HIGHLEVEL_CATEGORIES[subtask]
+    matches = [
+        word for word in categories
+        if re.search(rf"(?<![A-Z_]){re.escape(word)}(?![A-Z_])", text)
+    ]
+    return matches[0] if len(matches) == 1 else None
+
+
+def parse_traj(text):
+    """
+    Parse trajectory text like "[0.001, -0.002], [0.003, -0.004]".
+    Returns an array with shape [N, 2].
+    """
+    np = get_numpy()
+    if not isinstance(text, str):
+        return np.zeros((0, 2))
+
+    # Match integers, floats, and scientific notation.
+    nums = re.findall(r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?", text)
+    if len(nums) < 2:
+        return np.zeros((0, 2))
+    if len(nums) % 2 != 0:
+        return np.zeros((0, 2))
+
+    arr = np.array(nums, dtype=float)
+    arr = arr.reshape(-1, 2)
+    return arr
+
+def compute_l2_error(gt, pred, dt=0.5):
+    """
+    gt, pred: np.array of shape [10, 2]
+    Returns: {1s, 3s, 5s, mean}
+    """
+    if gt.shape != pred.shape or gt.shape[0] == 0:
+        return {"1s": None, "3s": None, "5s": None, "mean": None}
+
+    np = get_numpy()
+    errors = np.linalg.norm(gt - pred, axis=1)
+    time_horizons = [1.0, 3.0, 5.0]
+    results = {}
+    for t in time_horizons:
+        idx = int(t / dt) - 1
+        idx = min(idx, len(errors) - 1)
+        results[f"{t:.0f}s"] = float(errors[idx])
+    results["mean"] = float(np.mean(errors))
+    return results
+
+
+def evaluate(pred_json):
+    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}")
+
+    highlevel_totals = {subtask: 0 for subtask in HIGHLEVEL_CATEGORIES}
+    highlevel_correct = {subtask: 0 for subtask in HIGHLEVEL_CATEGORIES}
+    highlevel_classwise = {
+        subtask: {category: {"total": 0, "correct": 0} for category in categories}
+        for subtask, categories in HIGHLEVEL_CATEGORIES.items()
+    }
+    highlevel_groups = {}
+    trajectory_items = []
+    traj_errors = []
+
+    mismatch_high = []
+
+    for item in data:
+        category = item["category"]
+
+        if category == "Planning-HighLevel":
+            original_id = item.get("original_id")
+            subtask = item.get("subtask")
+            if not original_id:
+                raise ValueError("Planning high-level sample is missing original_id")
+            if subtask not in HIGHLEVEL_CATEGORIES:
+                raise ValueError(f"Missing or invalid planning high-level subtask: {subtask!r}")
+
+            group = highlevel_groups.setdefault(original_id, {})
+            if subtask in group:
+                raise ValueError(f"Duplicate planning high-level subtask {subtask!r} for {original_id}")
+            group[subtask] = item
+        elif category == "Planning-Trajectory":
+            trajectory_items.append(item)
+        else:
+            raise ValueError(f"Unexpected planning category: {category!r}")
+
+    for original_id, group in highlevel_groups.items():
+        if set(group) != REQUIRED_HIGHLEVEL_SUBTASKS:
+            raise ValueError(f"Incomplete planning high-level subtask pair for {original_id}: {sorted(group)}")
+
+    joint_correct = 0
+    for original_id, group in tqdm(highlevel_groups.items(), desc="Evaluating planning intent pairs"):
+        is_joint_correct = True
+        for subtask, item in group.items():
+            gt_raw = item["conversations"][1]["value"]
+            pred_raw = item.get("model_output", "")
+            gt = parse_highlevel_prediction(gt_raw, subtask)
+            pred = parse_highlevel_prediction(pred_raw, subtask)
+            if gt is None:
+                raise ValueError(f"Invalid planning {subtask} ground-truth answer: {gt_raw!r}")
+
+            highlevel_totals[subtask] += 1
+            highlevel_classwise[subtask][gt]["total"] += 1
+            is_correct = gt == pred
+            is_joint_correct = is_joint_correct and is_correct
+            if is_correct:
+                highlevel_correct[subtask] += 1
+                highlevel_classwise[subtask][gt]["correct"] += 1
+            else:
+                mismatch_high.append({
+                    "original_id": original_id,
+                    "image": item["image"],
+                    "subtask": subtask,
+                    "gt": gt,
+                    "pred": pred,
+                    "model_output": pred_raw,
+                })
+        joint_correct += is_joint_correct
+
+    for item in tqdm(trajectory_items, desc="Evaluating planning trajectories"):
+        gt_raw = item["conversations"][1]["value"]
+        pred_raw = item.get("model_output", "")
+        gt_traj = parse_traj(gt_raw)
+        pred_traj = parse_traj(pred_raw)
+        if gt_traj.shape[0] != 10:
+            raise ValueError(f"Invalid planning trajectory ground truth for {item['image']}: {gt_raw!r}")
+        if pred_traj.shape[0] != 10:
+            raise ValueError(
+                f"Invalid planning trajectory prediction for {item['image']}: "
+                f"expected exactly 10 waypoints, got {pred_traj.shape[0]}"
+            )
+        traj_errors.append(compute_l2_error(gt_traj, pred_traj))
+
+    results = {}
+    total_high = sum(highlevel_totals.values())
+    original_questions = len(highlevel_groups)
+
+    if total_high > 0:
+        results["HighLevel"] = {
+            "total": total_high,
+            "original_questions": original_questions,
+            "overall_accuracy (%)": round(sum(highlevel_correct.values()) / total_high * 100, 2),
+            "joint_correct": joint_correct,
+            "joint_accuracy (%)": round(joint_correct / original_questions * 100, 2),
+            "subtasks": {
+                subtask: {
+                    "total": highlevel_totals[subtask],
+                    "accuracy (%)": round(highlevel_correct[subtask] / highlevel_totals[subtask] * 100, 2)
+                    if highlevel_totals[subtask]
+                    else None,
+                    "classwise": {
+                        category: round(stats["correct"] / stats["total"] * 100, 2) if stats["total"] else None
+                        for category, stats in highlevel_classwise[subtask].items()
+                    },
+                }
+                for subtask in HIGHLEVEL_CATEGORIES
+            },
+        }
+
+    total_traj = len(trajectory_items)
+    if total_traj > 0:
+        results["Trajectory"] = {
+            "total": total_traj,
+            "valid_predictions": total_traj,
+            "invalid_predictions": 0,
+        }
+        if traj_errors:
+            np = get_numpy()
+            traj_errs_np = {
+                k: np.mean([error[k] for error in traj_errors if error[k] is not None])
+                for k in ["1s", "3s", "5s", "mean"]
+            }
+            results["Trajectory"]["avg_L2_error_m"] = {k: round(v, 4) for k, v in traj_errs_np.items()}
+
+    print("\n=== Evaluation Summary ===")
+    print(json.dumps(results, indent=2))
+
+    result_path = pred_json.replace(".json", "_eval_results.json")
+    with open(result_path, "w", encoding="utf-8") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+
+    with open(pred_json.replace(".json", "_highlevel_mismatch.json"), "w", encoding="utf-8") as f:
+        json.dump(mismatch_high, f, indent=2, ensure_ascii=False)
+    print(f"Evaluation summary saved to {result_path}")
+
+    return results
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Evaluate EventDrive planning task results.")
+    parser.add_argument("--pred-json", required=True, help="Path to prediction JSON with model_output fields.")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    evaluate(args.pred_json)

scripts/evaluation_prediction.py

@@ -0,0 +1,165 @@
+import argparse
+import json
+import re
+from tqdm import tqdm
+
+
+SUBTASK_CATEGORIES = {
+    "speed": ["KEEP", "ACCELERATE", "DECELERATE", "STOP"],
+    "path": ["LEFT", "RIGHT", "STRAIGHT", "UNKNOWN"],
+}
+REQUIRED_SUBTASKS = set(SUBTASK_CATEGORIES)
+
+
+def clean_text(s: str):
+    """Normalize whitespace and punctuation."""
+    if not isinstance(s, str):
+        return ""
+    s = s.strip()
+    s = re.sub(r"[.\n\r]+", " ", s)
+    s = re.sub(r"\s+", " ", s)
+    return s.strip()
+
+
+def parse_prediction(text, subtask):
+    """
+    Parse one split-task prediction:
+    "B ACCELERATE" -> "ACCELERATE"
+    "C STRAIGHT" -> "STRAIGHT"
+    """
+    if subtask not in SUBTASK_CATEGORIES:
+        raise ValueError(f"Unexpected prediction subtask: {subtask!r}")
+
+    text = clean_text(text).upper()
+    categories = SUBTASK_CATEGORIES[subtask]
+    matches = [
+        word for word in categories
+        if re.search(rf"(?<![A-Z_]){re.escape(word)}(?![A-Z_])", text)
+    ]
+    return matches[0] if len(matches) == 1 else None
+
+
+def group_split_samples(data):
+    groups = {}
+    for item in data:
+        original_id = item.get("original_id")
+        subtask = item.get("subtask")
+        if not original_id:
+            raise ValueError("Prediction sample is missing original_id")
+        if subtask not in SUBTASK_CATEGORIES:
+            raise ValueError(f"Missing or invalid prediction subtask: {subtask!r}")
+
+        group = groups.setdefault(original_id, {})
+        if subtask in group:
+            raise ValueError(f"Duplicate prediction subtask {subtask!r} for {original_id}")
+        group[subtask] = item
+
+    for original_id, group in groups.items():
+        if set(group) != REQUIRED_SUBTASKS:
+            raise ValueError(f"Incomplete prediction subtask pair for {original_id}: {sorted(group)}")
+    return groups
+
+
+def evaluate(pred_json):
+    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}")
+
+    groups = group_split_samples(data)
+    totals = {subtask: 0 for subtask in SUBTASK_CATEGORIES}
+    correct = {subtask: 0 for subtask in SUBTASK_CATEGORIES}
+    classwise = {
+        subtask: {category: {"total": 0, "correct": 0} for category in categories}
+        for subtask, categories in SUBTASK_CATEGORIES.items()
+    }
+    mismatch_examples = []
+    joint_correct = 0
+
+    for original_id, group in tqdm(groups.items(), desc="Evaluating prediction pairs"):
+        is_joint_correct = True
+        for subtask, item in group.items():
+            gt_raw = item["conversations"][1]["value"]
+            pred_raw = item.get("model_output", "")
+
+            gt = parse_prediction(gt_raw, subtask)
+            pred = parse_prediction(pred_raw, subtask)
+            if gt is None:
+                raise ValueError(f"Invalid {subtask} ground-truth answer: {gt_raw!r}")
+
+            totals[subtask] += 1
+            classwise[subtask][gt]["total"] += 1
+            is_correct = gt == pred
+            is_joint_correct = is_joint_correct and is_correct
+            if is_correct:
+                correct[subtask] += 1
+                classwise[subtask][gt]["correct"] += 1
+            else:
+                mismatch_examples.append({
+                    "original_id": original_id,
+                    "image": item["image"],
+                    "bbox_2d": item.get("bbox_2d", {}),
+                    "subtask": subtask,
+                    "gt": gt,
+                    "pred": pred,
+                    "model_output": pred_raw,
+                })
+        joint_correct += is_joint_correct
+
+    total = sum(totals.values())
+    original_questions = len(groups)
+    overall_acc = sum(correct.values()) / total * 100
+    joint_acc = joint_correct / original_questions * 100
+
+    print(f"\nTotal samples: {total}")
+    print(f"Original questions: {original_questions}")
+    for subtask in SUBTASK_CATEGORIES:
+        accuracy = correct[subtask] / totals[subtask] * 100 if totals[subtask] else 0.0
+        print(f"{subtask.upper()} accuracy: {accuracy:.2f}% ({correct[subtask]}/{totals[subtask]})")
+    print(f"Overall accuracy: {overall_acc:.2f}%")
+    print(f"Joint accuracy: {joint_acc:.2f}% ({joint_correct}/{original_questions})")
+    print(f"Wrong examples: {len(mismatch_examples)}")
+
+    result_summary = {
+        "total": total,
+        "original_questions": original_questions,
+        "overall_accuracy (%)": round(overall_acc, 2),
+        "joint_correct": joint_correct,
+        "joint_accuracy (%)": round(joint_acc, 2),
+        "subtasks": {
+            subtask: {
+                "total": totals[subtask],
+                "accuracy (%)": round(correct[subtask] / totals[subtask] * 100, 2) if totals[subtask] else None,
+                "classwise": {
+                    category: round(stats["correct"] / stats["total"] * 100, 2) if stats["total"] else None
+                    for category, stats in classwise[subtask].items()
+                },
+            }
+            for subtask in SUBTASK_CATEGORIES
+        },
+    }
+
+    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 EventDrive prediction task results.")
+    parser.add_argument("--pred-json", required=True, help="Path to prediction JSON with model_output fields.")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    evaluate(args.pred_json)

scripts/evaluation_understanding.py

@@ -0,0 +1,302 @@
+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)