| |
| """Record time-to-success from closed event logs, without querying a simulator.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from pathlib import Path |
|
|
| NATIVE_SUCCESS_FIELDS = { |
| "simpler_env": "success", "libero": "native_success", |
| "robocasa365": "native_success", "simple_humanoid": "native_success", |
| "robocasa_tabletop": "native_success", "robodojo": "native_success", |
| } |
|
|
|
|
| def summarize_progress(run: Path) -> dict: |
| run = run.resolve(strict=True) |
| lifecycle = json.loads((run / "status.json").read_text()) |
| if lifecycle.get("status") not in ("completed", "completed_with_errors"): |
| raise ValueError("progress analysis requires a closed run") |
| manifest = json.loads((run / "manifest.json").read_text()) |
| field = NATIVE_SUCCESS_FIELDS.get(manifest["benchmark"]["name"]) |
| rows = [] |
| for result_path in sorted((run / "episodes").glob("*/result.json")): |
| if not result_path.resolve().is_relative_to(run): |
| raise ValueError("episode result must remain inside the run") |
| result = json.loads(result_path.read_text()) |
| events_path = result_path.parent / "events.jsonl" |
| if not events_path.resolve().is_relative_to(run): |
| raise ValueError("episode events must remain inside the run") |
| events = [json.loads(line) for line in events_path.read_text().splitlines() if line] |
| steps = [event for event in events if event.get("event") == "environment_step"] |
| scored = [event for event in steps if type(event.get("info", {}).get(field)) is bool] if field else [] |
| coverage = ( |
| bool(field) and len(scored) == result["environment_steps"] |
| and [event["environment_step"] for event in scored] == list(range(1, result["environment_steps"] + 1)) |
| ) |
| successful = [event for event in scored if event["info"][field]] |
| first = successful[0] if successful else None |
| trailing = 0 |
| for event in reversed(scored): |
| if not event["info"][field]: |
| break |
| trailing += 1 |
| rows.append({ |
| "episode": result["episode"], "status": result["status"], |
| "native_success_field": field, "complete_step_coverage": coverage, |
| "first_native_success_step": first["environment_step"] if first and coverage else None, |
| "policy_call_at_first_native_success": first["policy_call"] if first and coverage else None, |
| "first_native_success_timestamp": first["timestamp"] if first and coverage else None, |
| "first_logged_success_step": first["environment_step"] if first else None, |
| "last_native_success_step": successful[-1]["environment_step"] if successful else None, |
| "successful_logged_steps": len(successful), |
| "consecutive_success_steps_at_end": trailing if coverage else None, |
| "final_environment_steps": result["environment_steps"], |
| "final_policy_calls": result["policy_calls"], "final_success": result["success"], |
| "termination_reason": result["termination_reason"], "error": result["error"], |
| "source_events": str(events_path), |
| }) |
| if len(rows) != lifecycle.get("episodes_written"): |
| raise ValueError("closed status and available episode records disagree") |
| return { |
| "schema_version": "starvla-rsi.closed-run-progress/v1", |
| "source_run": str(run), "benchmark": manifest["benchmark"], "protocol": manifest["protocol"], |
| "method": "existing native step info only; no simulator or extra scorer call", |
| "interpretation": "First success is diagnostic and does not replace final native scoring. Null is not an estimated step.", |
| "episodes": rows, |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--run-dir", type=Path, required=True) |
| parser.add_argument("--output", type=Path, required=True, help="new derived report; never overwrite source results") |
| args = parser.parse_args() |
| report = summarize_progress(args.run_dir) |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| with args.output.open("x") as handle: |
| json.dump(report, handle, indent=2, sort_keys=True) |
| handle.write("\n") |
| print(args.output) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
