ww_index: window list, captions, lags and scripts to rebuild the WildWorld windows from upstream
a54e6a7 verified Download ww_index/scripts/ww_offset_est.py from yuzhewu207/wizard-precoded: direct link, hf CLI and curl.
- Browser
- Download file 8.14 kB
-
https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/ww_offset_est.py
- Command line
-
hf download hf://datasets/yuzhewu207/wizard-precoded/ww_index/scripts/ww_offset_est.py
-
curl -L -o ww_offset_est.py https://huggingface.co/datasets/yuzhewu207/wizard-precoded/resolve/main/ww_index/scripts/ww_offset_est.py
8.14 kB
| """Per-session state<->video lag estimate for WildWorld. For a few frames of 2 windows per session, SAM2 (point grid) | |
| gives object masks that do not depend on the state; the monster's state joints are projected at shifts s in [-90, 90] | |
| and the shift whose projection falls best inside one object mask wins. A constant per-session lag was seen by eye | |
| (bear session ~-40, most sessions 0). Output: ww_offsets.json {sid: {best_s, score_best, score_0, n_frames, ...}}. | |
| python ww_offset_est.py <shard> <nshards> [sessions_csv] (CUDA_VISIBLE_DEVICES picks the GPU)""" | |
| import glob, json, subprocess, sys, time | |
| from pathlib import Path | |
| import numpy as np, torch | |
| from PIL import Image | |
| sys.path.insert(0, "/data/yuzhewu/runs/proxykit"); sys.path.insert(0, "/data/yuzhewu/datasets/wildworld") | |
| import ww_to_bossv2v as ww | |
| from proxykit.geometry import Camera, quat_from_matrix | |
| from transformers import Sam2Model, Sam2Processor | |
| ROOT = Path("/data/yuzhewu/datasets/wildworld"); edges = json.load(open(ROOT / "skeleton_edges.json")) | |
| SHIFTS = np.arange(-90, 91); FRAMES = (20, 60, 100); GRID = (24, 14); DEV = "cuda" | |
| model = Sam2Model.from_pretrained("facebook/sam2.1-hiera-large", torch_dtype=torch.bfloat16).to(DEV).eval(); proc = Sam2Processor.from_pretrained("facebook/sam2.1-hiera-large") | |
| def masks_for(img): | |
| """SAM2 masks from a point grid: list of bool (720,1280) masks, deduped, 0.3%..50% of the frame.""" | |
| W, H = img.size; xs = (np.arange(GRID[0]) + 0.5) / GRID[0] * W; ys = (np.arange(GRID[1]) + 0.5) / GRID[1] * H | |
| pts = [[[float(x), float(y)]] for y in ys for x in xs] | |
| inputs = proc(images=img, input_points=[pts], input_labels=[[[1]] * len(pts)], return_tensors="pt").to(DEV) | |
| with torch.no_grad(): | |
| out = model(**{k: (v.to(torch.bfloat16) if v.dtype == torch.float32 else v) for k, v in inputs.items()}, multimask_output=True) | |
| m = proc.post_process_masks(out.pred_masks.float().cpu(), inputs["original_sizes"].cpu())[0] # (N, 3, H, W) bool | |
| iou = out.iou_scores.float().cpu()[0] # (N, 3) | |
| best = iou.argmax(-1); m = m[torch.arange(len(m)), best].numpy(); iou = iou[torch.arange(len(iou)), best].numpy() | |
| keep = [] | |
| for k in np.argsort(-iou): | |
| a = m[k].mean() | |
| if not (0.003 <= a <= 0.5): continue | |
| if any((m[k] & m[j]).sum() / max((m[k] | m[j]).sum(), 1) > 0.8 for j in keep): continue | |
| keep.append(k) | |
| return [m[k] for k in keep] | |
| def session_tables(sid): | |
| sd = ROOT / "data_part1" / sid; st = ww.load_state(sd / "state.csv"); z = np.load(sd / "skeleton.npz"); keys = {k[0]: k for k in z.files}; km = keys["m"] | |
| parts = ww.assign_parts(z[km], edges[f"em_{km.split('_', 1)[1]}"], st["monster.list.1.rot"], "m")[0] | |
| return st, z[km], np.asarray(parts) > 0, len(z[km]) | |
| def project(st, Jm, ok, t, ground): | |
| if t < 0 or t >= len(Jm) or np.isnan(st["camera.rot"][t]).any(): return None | |
| Rgl = ww.q2R(st["camera.rot"][t]); M = np.stack([ww.S_SWAP(-Rgl[:, 2]), ww.S_SWAP(Rgl[:, 0]), ww.S_SWAP(Rgl[:, 1])], 1) | |
| K = st["camera.K"][t]; cam = Camera(ww.S_SWAP(st["camera.pos"][t] - np.array([0, ground, 0])) * 100, quat_from_matrix(M), float(np.degrees(2 * np.arctan(640 / K[0]))), 1280, 720) | |
| P = ww.S_SWAP(Jm[t] - np.array([0, ground, 0])) * 100; good = ok & ~np.isnan(P).any(1) | |
| if good.sum() < 6: return None | |
| uv, d = cam.project(P[good]); vis = d > 50 | |
| return uv[vis] if vis.sum() >= 6 else None | |
| def hull_mask(uv): | |
| """Filled convex hull of the projected joints (monotone chain), as a bool (720,1280) mask.""" | |
| from PIL import ImageDraw | |
| pts = sorted(set((float(x), float(y)) for x, y in uv)) | |
| if len(pts) < 3: return None | |
| cross = lambda o, a, b: (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]) | |
| lo, up = [], [] | |
| for q in pts: | |
| while len(lo) >= 2 and cross(lo[-2], lo[-1], q) <= 0: lo.pop() | |
| lo.append(q) | |
| for q in reversed(pts): | |
| while len(up) >= 2 and cross(up[-2], up[-1], q) <= 0: up.pop() | |
| up.append(q) | |
| hull = lo[:-1] + up[:-1] | |
| im = Image.new("L", (1280, 720), 0); ImageDraw.Draw(im).polygon(hull, fill=255) | |
| return np.asarray(im) > 0 | |
| def frame_score(masks, uv): | |
| """max over SAM masks of IoU(convex hull of projected joints, mask); 0 if the hull is mostly off-screen.""" | |
| ins = (uv[:, 0] >= 0) & (uv[:, 0] < 1280) & (uv[:, 1] >= 0) & (uv[:, 1] < 720) | |
| if ins.mean() < 0.6: return 0.0 | |
| hm = hull_mask(np.stack([np.clip(uv[:, 0], 0, 1279), np.clip(uv[:, 1], 0, 719)], 1)) | |
| if hm is None or hm.sum() < 200: return 0.0 | |
| best = 0.0 | |
| for m in masks: | |
| inter = (hm & m).sum() | |
| if inter == 0: continue | |
| best = max(best, inter / (hm | m).sum()) | |
| return float(best) | |
| def estimate(sid, wins): | |
| st, Jm, ok, n = session_tables(sid); rows = []; t_start = time.time() | |
| for win in wins: | |
| m = json.load(open(ROOT / "windows_121" / win / "meta.json")); t0 = m["t0"]; ground = m["ground_y_m"] | |
| for i in FRAMES: | |
| uv0 = project(st, Jm, ok, t0 + i, ground) | |
| if uv0 is None: continue | |
| fp = Path("/tmp/claude-2007/-home-yuzhewu/5fdd2e27-0190-4cf5-b6bf-9a4d1f89d67d/scratchpad") / f"off_{sid}_{i}.png"; fp.parent.mkdir(parents=True, exist_ok=True) | |
| subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", str(ROOT / "windows_121" / win / "rgb.mp4"), "-vf", f"select=eq(n\\,{i}),scale=1280:720", "-vframes", "1", str(fp)], check=False) | |
| if not fp.exists(): continue | |
| masks = masks_for(Image.open(fp).convert("RGB")); fp.unlink() | |
| if not masks: continue | |
| sc = np.zeros(len(SHIFTS)) | |
| for k, s in enumerate(SHIFTS): | |
| uv = project(st, Jm, ok, t0 + i + s, ground) | |
| sc[k] = frame_score(masks, uv) if uv is not None else 0.0 | |
| rows.append(sc) | |
| if not rows: return dict(sid=sid, n_frames=0) | |
| k0 = int(np.where(SHIFTS == 0)[0][0]) | |
| def width(r): # frames of the plateau within 90% of the peak: sharp = informative | |
| return int((r >= 0.9 * r.max()).sum()) | |
| info = [r for r in rows if r.max() - np.median(r) >= 0.12 and width(r) <= 12] # a real, sharp peak | |
| use = info if info else rows | |
| tot = np.mean(use, 0); k = int(np.argmax(tot)); pf = [int(SHIFTS[int(np.argmax(r))]) for r in use] | |
| return dict(sid=sid, n_frames=len(rows), n_info=len(info), best_s=int(SHIFTS[k]), median_s=int(np.median(pf)), spread=int(max(pf) - min(pf)), | |
| score_best=float(tot[k]), score_0=float(tot[k0]), score_med=float(np.median(tot)), | |
| per_frame_best=[int(SHIFTS[int(np.argmax(r))]) for r in rows], per_frame_peak=[round(float(r.max() - np.median(r)), 2) for r in rows], | |
| per_frame_width=[width(r) for r in rows], curves=[np.round(r, 3).tolist() for r in rows], secs=round(time.time() - t_start, 1)) | |
| if __name__ == "__main__": | |
| shard, nsh = int(sys.argv[1]), int(sys.argv[2]) | |
| by_sid = {} | |
| for f in sorted(glob.glob(str(ROOT / "windows_121" / "*/meta.json"))): | |
| win = Path(f).parent.name; sid = win.rsplit("_", 1)[0] | |
| if (ROOT / "data_part1" / sid).exists(): by_sid.setdefault(sid, []).append(win) | |
| sids = sys.argv[3].split(",") if len(sys.argv) > 3 else sorted(by_sid) | |
| out = Path(ROOT / f"ww_offsets_shard{shard}.json"); res = json.load(open(out)) if out.exists() else {} | |
| for n, sid in enumerate(sids): | |
| if n % nsh != shard or sid in res: continue | |
| w = by_sid[sid]; pick = [w[0], w[len(w) // 2]] if len(w) > 1 else w[:1] | |
| r = estimate(sid, pick); res[sid] = r; json.dump(res, open(out, "w"), indent=1) | |
| print(f"[{time.strftime('%H:%M:%S')}] {sid} frames {r.get('n_frames')} best_s {r.get('best_s')} median_s {r.get('median_s')} spread {r.get('spread')} info {r.get('n_info')} score {r.get('score_best', 0):.2f} (s=0: {r.get('score_0', 0):.2f}, med {r.get('score_med', 0):.2f}) per-frame {r.get('per_frame_best')} peaks {r.get('per_frame_peak')} widths {r.get('per_frame_width')} {r.get('secs')}s", flush=True) | |
| print("SHARD_DONE", shard) | |