Buckets:
| #!/usr/bin/env python | |
| """Review videos for human progress labels: camera + [combined, your label, model prediction]. | |
| For every labelled episode in a labelling-UI results JSONL, renders <out>/episode_XXXXXX.mp4 | |
| with three stacked panels over the labelled segments (light/dark green = progress slow/fast, | |
| red = mistake, light grey = adjust, dark grey = catastrophic): | |
| Combined generate_progress.py --mode fuse (what --mode fuse would write to progress.npy) | |
| Your label generate_progress.py --mode clipped | |
| <model> <pred-root>/episode_XXXXXX/pred.npy | |
| Nothing is written into the episode dirs, so this previews --mode fuse. | |
| ./.venv/bin/python tools/render_label_review.py \\ | |
| --results label_data/data/<task>/results/<file>.jsonl \\ | |
| --pred-root videos/g58_fold_all_first30 --out videos/fold_all30_fused | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import re | |
| import sys | |
| from pathlib import Path | |
| import numpy as np | |
| REPO = Path(__file__).resolve().parents[1] | |
| sys.path.insert(0, str(REPO)) | |
| sys.path.insert(0, str(REPO / "label_data/rollout_label/scripts")) | |
| import generate_progress as gp # noqa: E402 | |
| from tools.make_sarm2_video import render_progressive # noqa: E402 | |
| from tools.predict_act_pri import decode_episode_frames # noqa: E402 | |
| SEGMENT_COLOURS = {"progress_slow": "#d3eed3", "progress_fast": "#9fd89f", "mistake": "#f6caca", | |
| "adjust": "#dcdcdc", "catastrophic": "#a0a0a0"} | |
| def main() -> None: | |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) | |
| ap.add_argument("--results", required=True, help="labelling-UI results JSONL") | |
| ap.add_argument("--pred-root", required=True, help="dir with episode_XXXXXX/pred.npy") | |
| ap.add_argument("--out", required=True, help="output dir for the review videos") | |
| ap.add_argument("--pred-weight", type=float, default=0.5, help="share of the prediction (as in --mode fuse)") | |
| ap.add_argument("--episodes", type=int, nargs="*", default=None, help="episode numbers (default: all labelled)") | |
| ap.add_argument("--model-name", default="SARM2 g58", help="panel title for the prediction") | |
| ap.add_argument("--video-file", default="top_camera-images-rgb.mp4", help="camera video inside each episode dir") | |
| args = ap.parse_args() | |
| pred_root = Path(args.pred_root).expanduser().resolve() | |
| out = Path(args.out).expanduser().resolve() | |
| out.mkdir(parents=True, exist_ok=True) | |
| episodes = [] | |
| for row in gp.load_labels(Path(args.results).expanduser()): | |
| ep_dir = gp.video_path_to_episode_dir(row["video_path"]) | |
| episodes.append((ep_dir, np.load(ep_dir / "timestamp.npy"), row["label"])) | |
| curves = gp.clipped_curves(episodes) # the shared speed needs every labelled episode | |
| order = sorted(range(len(episodes)), key=lambda i: episodes[i][0].name) | |
| for i in order: | |
| ep_dir, timestamp, label = episodes[i] | |
| ep = int(re.search(r"(\d+)$", ep_dir.name).group(1)) | |
| if args.episodes is not None and ep not in args.episodes: | |
| continue | |
| clipped = curves[i][0] | |
| pred = np.load(pred_root / ep_dir.name / "pred.npy").astype(np.float64).reshape(-1) | |
| fused, note = gp.compute_progress_fused(timestamp, label, clipped, pred, args.pred_weight) | |
| t = timestamp - timestamp[0] | |
| fps = int(round(1.0 / float(np.median(np.diff(t))))) | |
| frames = decode_episode_frames(ep_dir / args.video_file, 0.0, fps, len(t)) | |
| n = min(len(t), len(frames)) | |
| spans = [(s["start"], s["end"], SEGMENT_COLOURS.get(s["label"], "#ffffff")) for s in label["segments"]] | |
| series = [("Combined", fused[:n], "#e8762b"), | |
| ("Your label", clipped[:n], "#20a8a4"), | |
| (args.model_name, np.clip(pred[:n], 0.0, 1.0), "#6b7484")] | |
| render_progressive(frames[:n], series, fps, out / f"{ep_dir.name}.mp4", | |
| title=f"ep {ep} final={label['final_progress']} ({args.pred_weight:.0%} model)", ylim=(0.0, 1.0), spans=spans) | |
| print(f"[ok] {ep_dir.name}: {n} frames | combined end {fused[n - 1]:.2f} peak {fused[:n].max():.2f} | " | |
| f"label end {clipped[n - 1]:.2f} | model end {pred[n - 1]:.2f}{note}", flush=True) | |
| print(f"[out] {out}") | |
| if __name__ == "__main__": | |
| main() | |
Xet Storage Details
- Size:
- 4.32 kB
- Xet hash:
- 49fd69b4e184c3039aa7e5f7649807a31d926295c23354bb70dda673a836e22b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.