File size: 8,341 Bytes
4ceeb65 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 | 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)
|