Ctrl-World-Graph/scripts/rollout_graph_episode.py

import argparse
import json
import sys
from pathlib import Path

import numpy as np
import torch

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from graphwm.config_graph import GraphWMArgs
from graphwm.cli_graph import add_graph_model_args, apply_graph_model_args, load_graph_model_config_sidecar
from graphwm.dataset.collate_graph_wm import collate_graph_wm
from graphwm.dataset.dataset_graph_wm import _load_rgb_frame
from graphwm.models.ctrl_world_graph import CtrlWorldGraph
from graphwm.original_ctrl_world import import_original_modules
from scripts.eval_graph_video import decode_latents_to_video, latest_checkpoint, psnr, write_video
from scripts.train_wm_graph import build_datasets


def _episode_frame_ids(episode_dir: Path, graph_dir_name: str) -> list[int]:
    rgb_dir = episode_dir / "side" / "rgb"
    graph_dir = episode_dir / graph_dir_name
    rgb_ids = {int(p.stem.split("_")[-1]) for p in rgb_dir.glob("frame_*.png")}
    graph_ids = {int(p.stem.split("_")[-1]) for p in graph_dir.glob("frame_*.pt")}
    return sorted(rgb_ids & graph_ids)


def _make_graph_batch(
    episode_dir: Path,
    graph_dir_name: str,
    frame_ids: list[int],
) -> dict:
    graph_seq = [
        torch.load(
            episode_dir / graph_dir_name / f"frame_{frame_id:06d}.pt",
            map_location="cpu",
            weights_only=False,
        )
        for frame_id in frame_ids
    ]
    return collate_graph_wm([{
        "graph_seq": graph_seq,
        "frame_ids": torch.tensor(frame_ids, dtype=torch.long),
        "text": "",
        "meta": {"episode_dir": str(episode_dir)},
    }])


def _load_rgb_batch(
    episode_dir: Path,
    frame_ids: list[int],
    resize_hw: tuple[int, int],
) -> torch.Tensor:
    frames = [
        _load_rgb_frame(episode_dir / "side" / "rgb" / f"frame_{frame_id:06d}.png", resize_hw)
        for frame_id in frame_ids
    ]
    return torch.stack(frames, dim=0).unsqueeze(0)


def _episode_from_val_dataset(val_ds, sample_index: int) -> Path:
    if hasattr(val_ds, "dataset") and hasattr(val_ds, "indices"):
        base_index = val_ds.indices[sample_index]
        return val_ds.dataset.samples[base_index][0]
    if hasattr(val_ds, "samples"):
        return val_ds.samples[sample_index][0]
    raise TypeError(f"Cannot infer episode dir from val dataset type {type(val_ds)!r}.")


def _spaced_window(frame_ids: list[int], current_offset: int, before: int, after: int, interval: int) -> list[int]:
    history = [
        frame_ids[current_offset - i * interval]
        for i in range(before, 0, -1)
    ]
    future = [
        frame_ids[current_offset + i * interval]
        for i in range(after)
    ]
    return history + future


def main():
    parser = argparse.ArgumentParser(description="Graph-conditioned episode rollout.")
    parser.add_argument("--ckpt-path", type=Path, default=None)
    parser.add_argument("--out-dir", type=Path, default=Path("/workspace/Ctrl-World-Graph/eval_videos"))
    parser.add_argument("--episode-dir", type=Path, default=None)
    parser.add_argument("--val-sample-index", type=int, default=0)
    parser.add_argument("--start-frame-offset", type=int, default=0)
    parser.add_argument("--max-output-frames", type=int, default=80)
    parser.add_argument("--save-fps", type=int, default=None)
    parser.add_argument(
        "--frame-interval",
        type=int,
        default=None,
        help="Override hanoi_frame_interval. Use 1 for pre-downsampled 5fps data "
        "(hanoi_0420_balanced_5fps); leave unset to use the config default (6 for 30fps data).",
    )
    parser.add_argument("--graph-mode", choices=["gt"], default="gt")
    parser.add_argument(
        "--rollout-mode",
        choices=["ar", "teacher_forced"],
        default="ar",
        help="ar feeds generated frames back as history; teacher_forced uses GT history/current for every chunk.",
    )
    add_graph_model_args(parser)
    cli = parser.parse_args()

    args = GraphWMArgs()
    args.ckpt_path = str(cli.ckpt_path or latest_checkpoint(Path(args.output_dir)))
    load_graph_model_config_sidecar(args, args.ckpt_path)
    apply_graph_model_args(args, cli)
    if cli.frame_interval is not None:
        args.hanoi_frame_interval = cli.frame_interval
    args.eval_batch_size = 1
    args.num_workers = 0

    _, val_ds = build_datasets(args)
    if cli.episode_dir is not None:
        episode_dir = cli.episode_dir
    else:
        episode_dir = _episode_from_val_dataset(val_ds, cli.val_sample_index)

    all_frame_ids = _episode_frame_ids(episode_dir, args.hanoi_graph_dir_name)
    frame_interval = args.hanoi_frame_interval
    current_offset = cli.start_frame_offset + args.num_history * frame_interval
    if current_offset >= len(all_frame_ids):
        raise ValueError(f"current_offset={current_offset} exceeds episode length={len(all_frame_ids)}")

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = CtrlWorldGraph(args).to(device)
    state_dict = torch.load(args.ckpt_path, map_location="cpu")
    model.load_state_dict(state_dict, strict=False)
    model.eval()

    original = import_original_modules(args.ctrl_world_root)
    CtrlWorldDiffusionPipeline = original["CtrlWorldDiffusionPipeline"]

    resize_hw = (args.height, args.width)
    initial_frame_ids = [
        all_frame_ids[cli.start_frame_offset + i * frame_interval]
        for i in range(args.num_history + 1)
    ]
    if len(initial_frame_ids) != args.num_history + 1:
        raise ValueError(f"Need {args.num_history + 1} initial frames, got {len(initial_frame_ids)}")

    with torch.no_grad():
        initial_rgb = _load_rgb_batch(episode_dir, initial_frame_ids, resize_hw).to(device)
        timeline_latents = [latent.detach().clone() for latent in model.encode_rgb_to_latents(initial_rgb)[0]]

    timeline_frame_ids = list(initial_frame_ids)
    chunk_records = []
    new_frames_per_chunk = args.num_frames - 1
    max_episode_offset = len(all_frame_ids) - 1 - new_frames_per_chunk * frame_interval

    with torch.no_grad():
        while (
            len(timeline_frame_ids) < cli.max_output_frames
            and current_offset <= max_episode_offset
        ):
            graph_frame_ids = _spaced_window(
                all_frame_ids,
                current_offset,
                before=args.num_history,
                after=args.num_frames,
                interval=frame_interval,
            )
            graph_batch = _make_graph_batch(episode_dir, args.hanoi_graph_dir_name, graph_frame_ids)
            graph_batch["graph_seq"] = [g.to(device) for g in graph_batch["graph_seq"]]
            graph_hidden = model.encode_graph_condition(graph_batch).to(device=device, dtype=model.unet.dtype)

            if cli.rollout_mode == "teacher_forced":
                context_frame_ids = _spaced_window(
                    all_frame_ids,
                    current_offset,
                    before=args.num_history,
                    after=1,
                    interval=frame_interval,
                )
                context_rgb = _load_rgb_batch(episode_dir, context_frame_ids, resize_hw).to(device)
                context_latents = model.encode_rgb_to_latents(context_rgb)[0]
                history = context_latents[:args.num_history].unsqueeze(0)
                current_latent = context_latents[args.num_history].unsqueeze(0)
            else:
                history = torch.stack(timeline_latents[-(args.num_history + 1):-1], dim=0).unsqueeze(0)
                current_latent = timeline_latents[-1].unsqueeze(0)

            _, pred_latents = CtrlWorldDiffusionPipeline.__call__(
                model.pipeline,
                image=current_latent,
                text=graph_hidden,
                width=args.width,
                height=args.height,
                num_frames=args.num_frames,
                history=history,
                num_inference_steps=args.num_inference_steps,
                decode_chunk_size=args.decode_chunk_size,
                max_guidance_scale=args.guidance_scale,
                fps=args.fps,
                motion_bucket_id=args.motion_bucket_id,
                output_type="latent",
                return_dict=False,
                frame_level_cond=args.frame_level_cond,
                his_cond_zero=args.his_cond_zero,
            )

            append_count = min(new_frames_per_chunk, cli.max_output_frames - len(timeline_frame_ids))
            for latent in pred_latents[0, 1:1 + append_count]:
                timeline_latents.append(latent.detach().clone())
            appended_frame_ids = [
                all_frame_ids[current_offset + i * frame_interval]
                for i in range(1, append_count + 1)
            ]
            timeline_frame_ids.extend(appended_frame_ids)
            chunk_records.append({
                "current_frame_id": all_frame_ids[current_offset],
                "graph_frame_ids": graph_frame_ids,
                "appended_frame_ids": appended_frame_ids,
                "history_source": "gt" if cli.rollout_mode == "teacher_forced" else "generated",
            })
            current_offset += new_frames_per_chunk * frame_interval

    rollout_latents = torch.stack(timeline_latents, dim=0).unsqueeze(0)
    pred_video = decode_latents_to_video(model.pipeline, rollout_latents, args.decode_chunk_size)[0]
    gt_rgb = _load_rgb_batch(episode_dir, timeline_frame_ids, resize_hw)[0]
    gt_video = (gt_rgb.permute(0, 2, 3, 1).clamp(0, 1) * 255).byte().cpu().numpy()
    compare_video = np.concatenate([gt_video, pred_video], axis=2)

    generated_start = args.num_history + 1
    mean_psnr, per_frame_psnr = psnr(pred_video[generated_start:], gt_video[generated_start:])

    ckpt_name = Path(args.ckpt_path).stem
    episode_name = f"{episode_dir.parent.name}_{episode_dir.name}"
    out_dir = (
        cli.out_dir
        / ckpt_name
        / f"rollout_{cli.rollout_mode}_{episode_name}_start{cli.start_frame_offset:04d}_n{len(timeline_frame_ids):04d}"
    )
    out_dir.mkdir(parents=True, exist_ok=True)

    save_fps = cli.save_fps or args.fps
    pred_path = out_dir / "pred_rollout.mp4"
    gt_path = out_dir / "gt_rollout.mp4"
    compare_path = out_dir / "compare_gt_left_pred_right.mp4"
    metrics_path = out_dir / "metrics.json"
    write_video(pred_path, pred_video, fps=save_fps)
    write_video(gt_path, gt_video, fps=save_fps)
    write_video(compare_path, compare_video, fps=save_fps)

    metrics = {
        "ckpt_path": args.ckpt_path,
        "episode_dir": str(episode_dir),
        "graph_mode": cli.graph_mode,
        "rollout_mode": cli.rollout_mode,
        "num_history": args.num_history,
        "num_frames": args.num_frames,
        "frame_interval": frame_interval,
        "source_fps": 30,
        "new_frames_per_chunk": new_frames_per_chunk,
        "model_condition_fps": args.fps,
        "save_fps": save_fps,
        "frame_ids": timeline_frame_ids,
        "generated_frame_ids": timeline_frame_ids[generated_start:],
        "psnr_mean_generated": mean_psnr,
        "psnr_per_generated_frame": per_frame_psnr,
        "chunks": chunk_records,
        "pred_path": str(pred_path),
        "gt_path": str(gt_path),
        "compare_path": str(compare_path),
    }
    metrics_path.write_text(json.dumps(metrics, indent=2), encoding="utf-8")
    print("saved_pred=", pred_path)
    print("saved_gt=", gt_path)
    print("saved_compare=", compare_path)
    print("saved_metrics=", metrics_path)
    print("num_output_frames=", len(timeline_frame_ids))
    print("psnr_mean_generated=", mean_psnr)


if __name__ == "__main__":
    main()