| """Recompute per-trajectory timing and recorded cumulative token statistics.""" |
|
|
| import csv |
| import json |
| import math |
| from collections import Counter |
| from concurrent.futures import ThreadPoolExecutor |
| from pathlib import Path |
|
|
|
|
| OUT = Path(__file__).resolve().parent |
| ROOT = OUT.parent / "robolab_full_task_1x_empirical_study" |
| TOKEN_FIELDS = ( |
| "inputTokens", "outputTokens", "totalTokens", "cachedInputTokens", |
| "cacheWriteInputTokens", "reasoningOutputTokens", |
| ) |
|
|
|
|
| def read_usage(path): |
| latest = {} |
| updates = 0 |
| decreases = [] |
| completed_turns = 0 |
| models = set() |
| last_line = 0 |
| with path.open("rb") as stream: |
| for line_number, line in enumerate(stream, 1): |
| |
| if not any(marker in line for marker in ( |
| b"thread/tokenUsage/updated", b'"thread/started"', |
| b'"turn/completed"', |
| )): |
| continue |
| row = json.loads(line) |
| if row.get("direction") != "receive": |
| continue |
| event = row.get("event", {}) |
| method = event.get("method") |
| params = event.get("params", {}) |
| if method == "thread/started": |
| models.add(params["thread"].get("model")) |
| elif method == "turn/completed": |
| completed_turns += 1 |
| elif method == "thread/tokenUsage/updated": |
| thread = params["threadId"] |
| usage = params["tokenUsage"]["total"] |
| assert all(type(usage.get(k)) is int and usage[k] >= 0 for k in TOKEN_FIELDS), path |
| assert usage["inputTokens"] + usage["outputTokens"] == usage["totalTokens"], path |
| assert usage["cachedInputTokens"] <= usage["inputTokens"], path |
| assert usage["reasoningOutputTokens"] <= usage["outputTokens"], path |
| if thread in latest and usage["totalTokens"] < latest[thread]["totalTokens"]: |
| decreases.append(line_number) |
| latest[thread] = usage |
| updates += 1 |
| last_line = line_number |
| assert latest, f"No token usage found: {path}" |
| assert not decreases, f"Cumulative token counter decreased: {path}: {decreases}" |
| return { |
| **{key: sum(usage[key] for usage in latest.values()) for key in TOKEN_FIELDS}, |
| "usage_updates": updates, |
| "thread_count": len(latest), |
| "completed_turn_events": completed_turns, |
| "last_usage_line": last_line, |
| "model": ";".join(sorted(m for m in models if m)), |
| "events_path": str(path.relative_to(ROOT)), |
| } |
|
|
|
|
| def main(): |
| rows = [] |
| result_files = sorted(ROOT.glob("*/episode_results.jsonl")) |
| for path in result_files: |
| for line_number, line in enumerate(path.read_text().splitlines(), 1): |
| episode = json.loads(line) |
| rows.append({ |
| "task_name": episode["task_name"], "run": episode["run"], |
| "env_id": episode["env_id"], "success": episode["success"], |
| "episode_step": episode["episode_step"], |
| **{key: episode["timing"][key] for key in ( |
| "policy_inference_s", "env_step_s", "video_write_s", "wall_total_s", |
| )}, |
| "result_path": str(path.relative_to(ROOT)), "result_line": line_number, |
| }) |
| rows.sort(key=lambda row: (row["task_name"], row["run"], row["env_id"])) |
| assert len(rows) == 1200 |
| assert len({(r["task_name"], r["run"], r["env_id"]) for r in rows}) == 1200 |
| tasks = Counter(r["task_name"] for r in rows) |
| assert len(tasks) == 120 and set(tasks.values()) == {10} |
| assert all(r["env_id"] == 0 for r in rows) |
| paths = [ROOT / "codex_log" / r["task_name"] / f"episode-{r['run'] + 1:04d}" / "events.jsonl" for r in rows] |
| assert set(paths) == set(ROOT.glob("codex_log/*/episode-*/events.jsonl")) |
| print(f"Scanning {len(paths)} event logs ({sum(p.stat().st_size for p in paths) / 1e9:.2f} GB)", flush=True) |
| with ThreadPoolExecutor(max_workers=8) as pool: |
| for index, (row, usage) in enumerate(zip(rows, pool.map(read_usage, paths)), 1): |
| row.update(usage) |
| row["uncachedInputTokens"] = row["inputTokens"] - row["cachedInputTokens"] |
| if index % 100 == 0: |
| print(f"Processed {index}/{len(rows)}", flush=True) |
| summary = { |
| "trajectory_count": len(rows), "task_count": len(tasks), |
| "trajectories_per_task": 10, "result_file_count": len(result_files), |
| "token_log_count": len(paths), |
| "success_count": sum(r["success"] for r in rows), |
| "models": dict(Counter(r["model"] for r in rows)), |
| "thread_count_distribution": dict(Counter(r["thread_count"] for r in rows)), |
| "logs_with_turn_completed": sum(r["completed_turn_events"] > 0 for r in rows), |
| "method": { |
| "harness_time": "episode_results.jsonl: timing.policy_inference_s; cumulative client-side policy-call elapsed time", |
| "total_execution_time": "timing.wall_total_s; sum of timed policy, environment-step and video-writing sections", |
| "tokens": "Latest recorded thread/tokenUsage/updated.params.tokenUsage.total per thread in each trajectory log; do not sum cumulative updates", |
| "cache": "cachedInputTokens is included in inputTokens; reasoningOutputTokens is included in outputTokens", |
| "coverage": "All 1200 trajectories, including successful and unsuccessful results; recorded token snapshots only", |
| }, |
| "metrics": {}, |
| } |
| for key in ("policy_inference_s", "env_step_s", "video_write_s", "wall_total_s", *TOKEN_FIELDS, "uncachedInputTokens"): |
| values = [r[key] for r in rows] |
| total = math.fsum(values) if key.endswith("_s") else sum(values) |
| summary["metrics"][key] = {"total": total, "mean_per_trajectory": total / len(rows)} |
| with (OUT / "per_trajectory.csv").open("w", newline="") as stream: |
| writer = csv.DictWriter(stream, fieldnames=list(rows[0])) |
| writer.writeheader() |
| writer.writerows(rows) |
| (OUT / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n") |
| print(json.dumps(summary, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
