| |
| """Freeze accepted CoDrive routes into a reproducible benchmark catalog.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import shutil |
| import statistics |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parents[2] |
| DEFAULT_DATASET_ROOT = PROJECT_ROOT / "closed_dataset" |
| DEFAULT_RUN_ROOT = DEFAULT_DATASET_ROOT / "acceptance_final_v1_runs" |
| DEFAULT_OUTPUT = DEFAULT_DATASET_ROOT / "acceptance_final_v1" |
|
|
|
|
| def _sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def _route_path(dataset_root: Path, route_id: str) -> Path: |
| matches = list((dataset_root / "routes").glob(f"*/{route_id}.xml")) |
| if len(matches) != 1: |
| raise RuntimeError(f"expected one XML for {route_id}, found {len(matches)}") |
| return matches[0] |
|
|
|
|
| def _report_path(run_root: Path, route_id: str) -> Path: |
| matches = list(run_root.glob(f"*/{route_id}/acceptance_report.json")) |
| if len(matches) != 1: |
| raise RuntimeError( |
| f"expected one acceptance report for {route_id}, found {len(matches)}" |
| ) |
| return matches[0] |
|
|
|
|
| def _format_average(values: list[float]) -> str: |
| return f"{statistics.fmean(values):.2f}" if values else "n/a" |
|
|
|
|
| def finalize(dataset_root: Path, run_root: Path, output: Path) -> dict: |
| manifest_path = dataset_root / "manifest.json" |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
| routes = manifest.get("routes", []) |
| if len(routes) != 60: |
| raise RuntimeError(f"expected 60 manifest routes, found {len(routes)}") |
|
|
| output.mkdir(parents=True, exist_ok=True) |
| reports_dir = output / "reports" |
| if reports_dir.exists(): |
| shutil.rmtree(reports_dir) |
| reports_dir.mkdir(parents=True) |
|
|
| scenario_path = dataset_root / "scenarios/closed_coopeval_scenarios.py" |
| validator_path = dataset_root / "scripts/validate_pdm_acceptance.py" |
| records = [] |
| errors = [] |
| for route in routes: |
| route_id = route["route_id"] |
| route_path = _route_path(dataset_root, route_id) |
| report_path = _report_path(run_root, route_id) |
| report = json.loads(report_path.read_text(encoding="utf-8")) |
| route_hash = _sha256(route_path) |
|
|
| route_errors = [] |
| if not report.get("accepted"): |
| route_errors.append("acceptance report rejected the route") |
| if report.get("route_sha256") != route_hash: |
| route_errors.append("route hash differs from the accepted XML") |
| if report.get("route_status") not in {"Completed", "Perfect"}: |
| route_errors.append(f"route status is {report.get('route_status')!r}") |
| if float(report.get("route_completion", 0.0)) < 99.0: |
| route_errors.append("route completion is below 99%") |
| if any(int(value) for value in report.get("collision_counts", {}).values()): |
| route_errors.append("collision count is nonzero") |
| if int(report.get("blocked_count", 0)): |
| route_errors.append("blocked count is nonzero") |
| if int(report.get("scenario_timeout_count", 0)): |
| route_errors.append("scenario timeout count is nonzero") |
| if not report.get("physical_completion_event"): |
| route_errors.append("physical completion event is missing") |
| if "hint_on" not in report.get("cooperative_agent_events", []): |
| route_errors.append("hint_on is missing") |
| if "hint_off" not in report.get("cooperative_agent_events", []): |
| route_errors.append("hint_off is missing") |
| if int(report.get("frame_count", 0)) <= 0: |
| route_errors.append("no RGB frames were saved") |
| if int(report.get("video_count", 0)) <= 0: |
| route_errors.append("no video was saved") |
|
|
| if route_errors: |
| errors.append({"route_id": route_id, "errors": route_errors}) |
|
|
| copied_report = reports_dir / route["family"] / f"{route_id}.json" |
| copied_report.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(report_path, copied_report) |
| records.append( |
| { |
| "route_id": route_id, |
| "family": route["family"], |
| "town": route["town"], |
| "source_route_id": route["source_route_id"], |
| "weather_profile": route["weather_profile"], |
| "route_length_m": route["route_length_m"], |
| "route_xml": str(route_path.relative_to(dataset_root)), |
| "route_sha256": route_hash, |
| "accepted": not route_errors, |
| "physical_completion_event": report.get("physical_completion_event"), |
| "event_release_reason": report.get("event_release_reason"), |
| "duration_game_s": report.get("duration_game_s"), |
| "frame_count": report.get("frame_count"), |
| "route_completion": report.get("route_completion"), |
| "variation": { |
| key: route[key] |
| for key in ( |
| "occluder_model", |
| "ped_age", |
| "cut_in_from", |
| "cut_in_model", |
| "deterministic_actor", |
| "obstacle_model", |
| "car_a_dir", |
| "ghost_model", |
| "ghost_speed", |
| "flow_speed", |
| ) |
| if key in route |
| }, |
| "evidence_run_dir": report.get("run_dir"), |
| } |
| ) |
|
|
| if errors: |
| raise RuntimeError(json.dumps(errors, indent=2)) |
|
|
| family_records: dict[str, list[dict]] = defaultdict(list) |
| for record in records: |
| family_records[record["family"]].append(record) |
|
|
| lock = { |
| "benchmark": "CoDrive", |
| "version": "1.0", |
| "route_count": len(records), |
| "manifest_sha256": _sha256(manifest_path), |
| "scenario_script_sha256": _sha256(scenario_path), |
| "acceptance_validator_sha256": _sha256(validator_path), |
| "source_xml_sha256": manifest["source_xml_sha256"], |
| "family_counts": dict(Counter(record["family"] for record in records)), |
| "acceptance": { |
| "accepted": len(records), |
| "rejected": 0, |
| "collision_routes": 0, |
| "blocked_routes": 0, |
| "timeout_routes": 0, |
| }, |
| "routes": records, |
| } |
| lock_path = dataset_root / "benchmark_v1.lock.json" |
| lock_path.write_text(json.dumps(lock, indent=2) + "\n", encoding="utf-8") |
|
|
| lines = [ |
| "# CoDrive Benchmark v1.0 Audit", |
| "", |
| "This file is generated by `closed_dataset/scripts/finalize_benchmark_v1.py`.", |
| "", |
| "## Release Contract", |
| "", |
| f"- Routes: {len(records)} total, 10 per scenario family.", |
| "- Static validation: passed.", |
| "- PDM-Lite acceptance: 60/60 passed.", |
| "- Collisions, blocked routes, and scenario timeouts: 0.", |
| "- Every run contains hint-on, physical completion, hint-off, RGB frames, and video.", |
| f"- Scenario implementation SHA256: `{lock['scenario_script_sha256']}`.", |
| "", |
| "## Scenario Summary", |
| "", |
| "| Scenario family | Routes | Towns | Weather profiles | Mean length (m) | Mean duration (s) |", |
| "| --- | ---: | ---: | ---: | ---: | ---: |", |
| ] |
| for family in sorted(family_records): |
| values = family_records[family] |
| lines.append( |
| "| {family} | {routes} | {towns} | {weather} | {length} | {duration} |".format( |
| family=family.replace("_", " ").title(), |
| routes=len(values), |
| towns=len({record["town"] for record in values}), |
| weather=len({record["weather_profile"] for record in values}), |
| length=_format_average( |
| [float(record["route_length_m"]) for record in values] |
| ), |
| duration=_format_average( |
| [float(record["duration_game_s"]) for record in values] |
| ), |
| ) |
| ) |
| lines.extend( |
| [ |
| "", |
| "## Reproduction", |
| "", |
| "Run the static and PDM-Lite validators before publishing modified routes:", |
| "", |
| "```bash", |
| "python closed_dataset/validate.py --root closed_dataset", |
| "python closed_dataset/scripts/run_pdm_acceptance_suite.py \\", |
| " --route-root closed_dataset/routes \\", |
| " --run-root closed_dataset/acceptance_final_v1_runs \\", |
| " --gpu 2 --graphics-adapter 0 --port 4897 --tm-port 10897 --rerun", |
| "python closed_dataset/scripts/finalize_benchmark_v1.py", |
| "```", |
| "", |
| "The exact XML hashes and evidence paths are recorded in", |
| "`closed_dataset/benchmark_v1.lock.json`.", |
| "", |
| ] |
| ) |
| (dataset_root / "BENCHMARK_V1_AUDIT.md").write_text( |
| "\n".join(lines), encoding="utf-8" |
| ) |
| catalog_lines = [ |
| "# CoDrive v1.0 Route Catalog", |
| "", |
| "| Route | Scenario family | Town | Weather | Length (m) | Source | Variation |", |
| "| --- | --- | --- | --- | ---: | --- | --- |", |
| ] |
| for record in sorted(records, key=lambda item: (item["family"], item["route_id"])): |
| variation = ", ".join( |
| f"{key}={value}" for key, value in sorted(record["variation"].items()) |
| ) |
| catalog_lines.append( |
| "| {route} | {family} | {town} | {weather} | {length:.2f} | {source} | {variation} |".format( |
| route=record["route_id"], |
| family=record["family"].replace("_", " ").title(), |
| town=record["town"], |
| weather=record["weather_profile"].replace("_", " "), |
| length=float(record["route_length_m"]), |
| source=record["source_route_id"], |
| variation=variation or "geometry and actor placement", |
| ) |
| ) |
| catalog_lines.append("") |
| (dataset_root / "ROUTE_CATALOG.md").write_text( |
| "\n".join(catalog_lines), encoding="utf-8" |
| ) |
| (output / "acceptance_summary.json").write_text( |
| json.dumps(lock, indent=2) + "\n", encoding="utf-8" |
| ) |
| return lock |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dataset-root", type=Path, default=DEFAULT_DATASET_ROOT) |
| parser.add_argument("--run-root", type=Path, default=DEFAULT_RUN_ROOT) |
| parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT) |
| args = parser.parse_args() |
| lock = finalize( |
| args.dataset_root.resolve(), |
| args.run_root.resolve(), |
| args.output.resolve(), |
| ) |
| print( |
| f"CoDrive v{lock['version']} frozen: " |
| f"{lock['acceptance']['accepted']}/{lock['route_count']} accepted" |
| ) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
