"""Rebuild the 224x224 training inputs used in the paper from the released data. python scripts/downscale_to_224.py SRC DST [--episodes 0-99] [--workers 8] SRC is action/train/manipulation or action/train/navigation (LeRobot v2.1). DST receives a LeRobot v2.1 dataset with every video stream at 224x224: - RGB streams (head, wrists): each frame resized with cv2.INTER_LINEAR, the same resize the original 224 conversion applied to the source recordings. The result matches what the paper's policies trained on to ~39 dB PSNR (head) / ~40 dB (wrists), but is not byte-identical: that set was resized straight from the source recordings and encoded once. - IR streams (manipulation): re-rendered at 224 from meta/ir_centers.jsonl with the paper's recipe, matching the trained-on IR exactly (up to video coding): target center scaled 720 -> 224 with round(); dot = radius 4 in #FF3333 over a 1 px white outline, drawn on the 224 head frame; first-frame stream = frame 0 of the dot stream repeated; attention map = standalone 224 grid with an isotropic Gaussian (sigma 8 px) through a jet colormap (background = jet(0); no target in view => uniform background). Measured against the trained-on 224 IR: dot ~37 dB, attention map ~52 dB (video-coding noise only). Parquet data, tasks and norm stats are copied unchanged. Video encoding uses the LeRobot defaults (libsvtav1, yuv420p, g=2, crf=30). Requires: av, numpy, opencv-python, pillow. """ import argparse, json, os, shutil from concurrent.futures import ProcessPoolExecutor import av import cv2 import numpy as np from PIL import Image, ImageDraw RES, FPS = 224, 30 DOT_RADIUS, OUTLINE, DOT_COLOR = 4, 1, "#FF3333" SIGMA, JET_MAX = 8.0, 0.875 RGB_KEYS = ("head_image", "left_wrist_image", "right_wrist_image") IR_KEYS = ("object_center_image", "object_center_first_image", "attn_map_image") def _jet_lut(): v = np.linspace(0.0, JET_MAX, 256) ch = [np.clip(1.5 - np.abs(4.0 * v - k), 0.0, 1.0) for k in (3.0, 2.0, 1.0)] return np.round(np.stack(ch, axis=1) * 255.0).astype(np.uint8) JET = _jet_lut() def scale_center(c, src): s = RES / src return None if c is None else (int(round(c[0] * s)), int(round(c[1] * s))) def draw_dot(rgb, c): if c is None: return rgb.copy() img = Image.fromarray(rgb) d = ImageDraw.Draw(img) r = DOT_RADIUS + OUTLINE d.ellipse([c[0] - r, c[1] - r, c[0] + r, c[1] + r], fill="white") d.ellipse([c[0] - DOT_RADIUS, c[1] - DOT_RADIUS, c[0] + DOT_RADIUS, c[1] + DOT_RADIUS], fill=DOT_COLOR) return np.asarray(img, dtype=np.uint8) def heatmap(c): if c is None: return np.broadcast_to(JET[0], (RES, RES, 3)).copy() ys = np.arange(RES, dtype=np.float32)[:, None] xs = np.arange(RES, dtype=np.float32)[None, :] g = np.exp(-((xs - c[0]) ** 2 + (ys - c[1]) ** 2) / (2.0 * SIGMA * SIGMA)) return JET[np.round(255.0 * g).astype(np.uint8)] def decode(path): with av.open(path) as c: return [f.to_ndarray(format="rgb24") for f in c.decode(c.streams.video[0])] def encode(frames, dst): os.makedirs(os.path.dirname(dst), exist_ok=True) tmp = dst + ".tmp.mp4" with av.open(tmp, "w") as c: s = c.add_stream("libsvtav1", rate=FPS) s.width = s.height = RES s.pix_fmt = "yuv420p" s.options = {"crf": "30", "g": "2", "preset": "8"} s.thread_count = 4 # SVT-AV1 can deadlock with unbounded threads for fr in frames: for p in s.encode(av.VideoFrame.from_ndarray(np.ascontiguousarray(fr), format="rgb24")): c.mux(p) for p in s.encode(): c.mux(p) os.replace(tmp, dst) def image_stats(frames, n=100): idx = np.linspace(0, len(frames) - 1, min(n, len(frames))).round().astype(int) x = np.stack([frames[i] for i in idx]).astype(np.float64) / 255.0 red = lambda f: [[[float(v)]] for v in f(x, axis=(0, 1, 2))] return {"min": red(np.min), "max": red(np.max), "mean": red(np.mean), "std": red(np.std), "count": [len(idx)]} def do_episode(args): src, dst, info, ep, centers = args vp = info["video_path"] path = lambda root, k: os.path.join(root, vp.format(episode_chunk=ep // info["chunks_size"], video_key=k, episode_index=ep)) keys = [k for k, f in info["features"].items() if f["dtype"] == "video"] stats, head = {}, None for k in keys: if k not in RGB_KEYS: continue fr = [cv2.resize(f, (RES, RES), interpolation=cv2.INTER_LINEAR) for f in decode(path(src, k))] if k == "head_image": head = fr encode(fr, path(dst, k)) stats[k] = image_stats(fr) if any(k in IR_KEYS for k in keys): cs = [scale_center(c, centers["image_size"]) for c in centers["centers"]] assert len(cs) == len(head), (ep, len(cs), len(head)) dot = [draw_dot(f, c) for f, c in zip(head, cs)] ir = {"object_center_image": dot, "object_center_first_image": [dot[0]] * len(dot), "attn_map_image": [heatmap(c) for c in cs]} for k in IR_KEYS: if k in keys: encode(ir[k], path(dst, k)) stats[k] = image_stats(ir[k]) return ep, stats def parse_range(s, n): if not s: return list(range(n)) a, b = s.split("-") return list(range(int(a), min(int(b) + 1, n))) def main(): ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("src") ap.add_argument("dst") ap.add_argument("--episodes", default="", help="inclusive range for spot checks, e.g. 0-9 (default: all; a subset " "does not produce a loadable dataset)") ap.add_argument("--workers", type=int, default=os.cpu_count() // 4 or 1) a = ap.parse_args() info = json.load(open(f"{a.src}/meta/info.json")) eps = parse_range(a.episodes, info["total_episodes"]) centers = {} if os.path.exists(f"{a.src}/meta/ir_centers.jsonl"): for line in open(f"{a.src}/meta/ir_centers.jsonl"): d = json.loads(line) if d["episode_index"] in eps: centers[d["episode_index"]] = d for sub in ("data",): shutil.copytree(f"{a.src}/{sub}", f"{a.dst}/{sub}", dirs_exist_ok=True) os.makedirs(f"{a.dst}/meta", exist_ok=True) for name in ("meta/episodes.jsonl", "meta/tasks.jsonl", "meta/ir_centers.jsonl", "norm_stats.json", "task_weights.json"): if os.path.exists(f"{a.src}/{name}"): shutil.copy2(f"{a.src}/{name}", f"{a.dst}/{name}") out_info = json.loads(json.dumps(info)) for f in out_info["features"].values(): if f["dtype"] == "video": f["shape"] = [RES, RES, 3] f["info"]["video.height"] = f["info"]["video.width"] = RES json.dump(out_info, open(f"{a.dst}/meta/info.json", "w"), indent=4) new_stats = {} jobs = [(a.src, a.dst, info, ep, centers.get(ep)) for ep in eps] with ProcessPoolExecutor(a.workers) as pool: for i, (ep, st) in enumerate(pool.map(do_episode, jobs)): new_stats[ep] = st if i % 50 == 0: print(f"{i + 1}/{len(eps)} episodes", flush=True) with open(f"{a.src}/meta/episodes_stats.jsonl") as fi, open(f"{a.dst}/meta/episodes_stats.jsonl", "w") as fo: for line in fi: e = json.loads(line) if e["episode_index"] in new_stats: e["stats"].update(new_stats[e["episode_index"]]) fo.write(json.dumps(e) + "\n") print("done:", a.dst) if __name__ == "__main__": main()