| 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) |
|
|
