#!/usr/bin/env python3 """ReCamMaster shard runner for the 81-frame contiguous query dataset. Why this is different from `recammaster_pad81_shard.py` -------------------------------------------------------- The pad81 shard works on the original 41-frame TestData and frame-pads to 81. This shard works on `query_datasets_2clips_per_uuid/frames_081/`, where each clip already contains a REAL 81-frame contiguous front.mp4 at 16 fps (5 s), matched by 5 GT view mp4s. Temporal alignment of the camera anchors ---------------------------------------- The pose file referenced from the manifest (`pose_pt`) is the original LongtailTest extraction. Its `T_anchor_front` is 11 anchors at 1 s spacing covering 0..10 s. The new 81-frame clip covers 0..5 s with 21 anchors at 0.25 s spacing. Because the existing `load_clip_geometry` densifies those 11 anchors into a 41-frame trajectory at 0.25 s spacing (frames 0..40 over 0..10 s), the **first 21 entries** of that densified trajectory are exactly the 21 anchors we need for the new 5-second clip. (Small per-frame timestamp jitter is <15 ms = ~6% of the 250 ms anchor spacing, negligible vs vehicle dynamics at typical driving speeds.) Outputs ------- Full 81-frame mp4 (NOT trimmed) to: results/recammaster_query81////.mp4 This matches the GT layout at: query_datasets_2clips_per_uuid/frames_081////.mp4 """ from __future__ import annotations import argparse import sys import time import traceback from pathlib import Path import numpy as np import torch EVALWM_ROOT = Path("/scratch/project/prj-02-phai-lab/lulin/longtail/evalWM") RECAM_ROOT = Path("/scratch/project/prj-02-phai-lab/lulin/longtail/ReCamMaster") sys.path.insert(0, str(EVALWM_ROOT / "run_baselines")) sys.path.insert(0, str(EVALWM_ROOT / "run_baselines" / "adapters")) sys.path.insert(0, str(RECAM_ROOT)) from io_utils import OUTPUT_FPS, load_manifest, shard_view_jobs # noqa: E402 from recammaster_one import load_source_video, DEFAULT_NEGATIVE_PROMPT # noqa: E402 from trajectory import load_clip_geometry, SENSOR_FROM_TAG # noqa: E402 SOURCE_FRAMES = 81 # real 81 contiguous frames from the query dataset NUM_ANCHORS = 21 # = (81-1)//4 + 1 OUTPUT_FRAMES = 81 # save the full 81-frame output (matches GT length) BASELINE_NAME = "recammaster_query81" DEFAULT_MANIFEST = EVALWM_ROOT / "run_baselines" / "query_datasets_2clips_per_uuid" / "frames_081" / "manifest.jsonl" def build_query81_pose_embedding(geo: dict, view: str) -> torch.Tensor: """(1, 21, 12) pose embedding for the 5-second 81-frame clip. Uses the first 21 frames of the densified 41-frame world_from_view trajectory produced by `load_clip_geometry`, expressed relative to `T_anchor_front[0]` (= identity since world = front_cam_0). """ sensor = SENSOR_FROM_TAG[view] T_view_41 = geo["T_world_from_cam_41_by_sensor"][sensor] # (41,4,4) T_view_21 = T_view_41[:NUM_ANCHORS] # (21,4,4) over 0..5 s T_front_anchor0 = geo["T_anchor_front_11"][0] # (4,4) ~identity inv0 = np.linalg.inv(T_front_anchor0) rel = inv0[None] @ T_view_21 # (21,4,4) rel_3x4 = rel[:, :3, :].astype(np.float32) rel_flat = rel_3x4.reshape(NUM_ANCHORS, 12) return torch.from_numpy(rel_flat).unsqueeze(0).to(torch.bfloat16) # (1,21,12) def output_path(row: dict, view: str) -> Path: """Match the GT directory-per-clip layout.""" return (EVALWM_ROOT / "results" / BASELINE_NAME / f"chunk_{row['chunk']}" / row["uuid"] / row["clip_id"] / f"{view}.mp4") def log_path(row: dict, view: str) -> Path: return (EVALWM_ROOT / "results" / BASELINE_NAME / "_logs" / f"chunk_{row['chunk']}_{row['uuid']}_{row['clip_id']}_{view}.log") def parse_args(): ap = argparse.ArgumentParser() ap.add_argument("--shard-idx", type=int, required=True) ap.add_argument("--num-shards", type=int, default=30) ap.add_argument("--num-steps", type=int, default=50) ap.add_argument("--cfg-scale", type=float, default=5.0) ap.add_argument("--seed", type=int, default=0) ap.add_argument("--height", type=int, default=480) ap.add_argument("--width", type=int, default=832) ap.add_argument("--max-jobs", type=int, default=0) ap.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST) return ap.parse_args() def main(): args = parse_args() manifest = load_manifest(args.manifest) jobs = shard_view_jobs(manifest, args.shard_idx, args.num_shards) if args.max_jobs > 0: jobs = jobs[: args.max_jobs] from diffsynth import ModelManager, WanVideoReCamMasterPipeline, save_video device = "cuda" print(f"[recam_query81] shard={args.shard_idx}/{args.num_shards} jobs={len(jobs)} " f"src_frames={SOURCE_FRAMES} anchors={NUM_ANCHORS} out_frames={OUTPUT_FRAMES}", flush=True) t_load = time.time() model_manager = ModelManager(torch_dtype=torch.bfloat16, device="cpu") model_manager.load_models([ str(RECAM_ROOT / "models" / "Wan-AI" / "Wan2.1-T2V-1.3B" / "diffusion_pytorch_model.safetensors"), str(RECAM_ROOT / "models" / "Wan-AI" / "Wan2.1-T2V-1.3B" / "models_t5_umt5-xxl-enc-bf16.pth"), str(RECAM_ROOT / "models" / "Wan-AI" / "Wan2.1-T2V-1.3B" / "Wan2.1_VAE.pth"), ]) pipe = WanVideoReCamMasterPipeline.from_model_manager(model_manager, device=device) dim = pipe.dit.blocks[0].self_attn.q.weight.shape[0] for block in pipe.dit.blocks: block.cam_encoder = torch.nn.Linear(12, dim) block.projector = torch.nn.Linear(dim, dim) block.cam_encoder.weight.data.zero_() block.cam_encoder.bias.data.zero_() block.projector.weight = torch.nn.Parameter(torch.eye(dim)) block.projector.bias = torch.nn.Parameter(torch.zeros(dim)) state_dict = torch.load( RECAM_ROOT / "models" / "ReCamMaster" / "checkpoints" / "step20000.ckpt", map_location="cpu", weights_only=False, ) if "state_dict" in state_dict: state_dict = state_dict["state_dict"] pipe.dit.load_state_dict(state_dict, strict=True) pipe.to(device); pipe.to(dtype=torch.bfloat16) print(f"[recam_query81] loaded ckpt in {time.time()-t_load:.1f}s", flush=True) done = skipped = failed = 0 for i, (row, view) in enumerate(jobs): out_path = output_path(row, view) if out_path.exists() and out_path.stat().st_size > 1000: skipped += 1 print(f" [{i+1}/{len(jobs)}] skip {out_path.relative_to(EVALWM_ROOT)}", flush=True) continue lp = log_path(row, view) lp.parent.mkdir(parents=True, exist_ok=True) t0 = time.time() try: geo = load_clip_geometry(row) pose_embed = build_query81_pose_embedding(geo, view).to(device) sv = load_source_video(row["front_mp4"], args.height, args.width, num_frames=SOURCE_FRAMES).to(device) # (T,3,H,W) source_video = sv.permute(1, 0, 2, 3).unsqueeze(0) # (1,3,T,H,W) assert source_video.shape[2] == SOURCE_FRAMES, source_video.shape assert pose_embed.shape == (1, NUM_ANCHORS, 12), pose_embed.shape # Text prompt: use UMT5 prompt cached at row["text_emb_pt"] if present. if row.get("text_emb_pt"): te = torch.load(row["text_emb_pt"], map_location="cpu", weights_only=False) prompt = te.get("prompt", "") or "A driving scene viewed from a vehicle-mounted camera." else: prompt = "A driving scene viewed from a vehicle-mounted camera." video = pipe( prompt=prompt, negative_prompt=DEFAULT_NEGATIVE_PROMPT, source_video=source_video, target_camera=pose_embed, cfg_scale=args.cfg_scale, num_inference_steps=args.num_steps, seed=args.seed, height=args.height, width=args.width, num_frames=SOURCE_FRAMES, tiled=True, ) assert len(video) == SOURCE_FRAMES, f"pipe returned {len(video)} frames, expected {SOURCE_FRAMES}" # Save full 81 frames (matches GT length) out_path.parent.mkdir(parents=True, exist_ok=True) tmp = out_path.with_suffix(".tmp.mp4") save_video(video, str(tmp), fps=OUTPUT_FPS, quality=5) tmp.rename(out_path) done += 1 print(f" [{i+1}/{len(jobs)}] ok {row['chunk']}/{row['uuid'][:8]}/{row['clip_id']}/{view} " f"{time.time()-t0:.0f}s", flush=True) torch.cuda.empty_cache() except Exception: failed += 1 tb = traceback.format_exc() lp.write_text(tb) print(f" [{i+1}/{len(jobs)}] FAIL {row['chunk']}/{row['uuid'][:8]}/{row['clip_id']}/{view}: " f"{tb.splitlines()[-1]}", flush=True) print(f"[recam_query81] done done={done} skipped={skipped} failed={failed}", flush=True) if __name__ == "__main__": main()