Ctrl-World/scripts/inference_world_model.py

"""
Full inference script: Delta Actions → Converter → Ctrl-World → Predicted Video

This demonstrates the complete inference pipeline:
  1. Load Ctrl-World model (from checkpoint)
  2. Load the action converter (MLP adapter)
  3. Given initial observation (latent + EE state) and delta actions:
     a. Convert delta actions → absolute EE states (via converter)
     b. Normalize states using dataset statistics
     c. Feed to world model → generate predicted future frames
     d. Decode latents → video
  4. Save predicted video (and optionally compare with ground truth)

Usage:
    cd /mnt/filesystem-g0/Dual-Dynamics-Models/Ctrl-World
    conda activate atm_ati_vdm

    # Basic inference with ground truth actions:
    CUDA_VISIBLE_DEVICES=0 python scripts/inference_world_model.py \
        --ckpt model_ckpt/libero_ctrlworld/checkpoint-20000.pt

    # Specific episode:
    CUDA_VISIBLE_DEVICES=0 python scripts/inference_world_model.py \
        --ckpt model_ckpt/libero_ctrlworld/checkpoint-20000.pt \
        --suite libero_goal_no_noops --episode 5

    # Use converter (delta actions → states) instead of ground truth states:
    CUDA_VISIBLE_DEVICES=0 python scripts/inference_world_model.py \
        --ckpt model_ckpt/libero_ctrlworld/checkpoint-20000.pt \
        --use_converter
"""

import argparse
import glob
import json
import os
import sys

import cv2
import einops
import mediapy
import numpy as np
import torch

os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from config_libero import wm_args
from models.ctrl_world import CrtlWorld
from models.pipeline_ctrl_world import CtrlWorldDiffusionPipeline
from models.libero_action_converter import LiberoActionConverter


def load_rlds_episode(rlds_dir, suite, episode_idx):
    """Load a single episode from RLDS TFRecords."""
    import tensorflow as tf
    tf.config.set_visible_devices([], "GPU")

    tfrecords = sorted(glob.glob(os.path.join(rlds_dir, suite, "1.0.0", "*.tfrecord*")))
    idx = 0
    for tfr in tfrecords:
        for rec in tf.data.TFRecordDataset(tfr):
            if idx == episode_idx:
                ex = tf.train.SequenceExample()
                ex.ParseFromString(rec.numpy())
                s8 = np.array(ex.context.feature["steps/observation/state"].float_list.value, dtype=np.float32).reshape(-1, 8)
                a7 = np.array(ex.context.feature["steps/action"].float_list.value, dtype=np.float32).reshape(-1, 7)
                lang = ex.context.feature["steps/language_instruction"].bytes_list.value[0].decode()
                T = min(s8.shape[0], a7.shape[0])
                s7 = np.column_stack([s8[:T, :6], s8[:T, 6] - s8[:T, 7]])
                return s7, a7[:T], lang
            idx += 1
    raise ValueError(f"Episode {episode_idx} not found")


def load_episode_latents(dataset_dir, episode_id):
    """Load preprocessed latent videos for an episode."""
    for split in ["train", "val"]:
        latent_dir = os.path.join(dataset_dir, "latent_videos", split, episode_id)
        if os.path.exists(latent_dir):
            view0 = torch.load(os.path.join(latent_dir, "0.pt"), map_location="cpu")
            view1 = torch.load(os.path.join(latent_dir, "1.pt"), map_location="cpu")
            view2 = torch.load(os.path.join(latent_dir, "2.pt"), map_location="cpu")
            T = view0.shape[0]
            stacked = torch.zeros(T, 4, 72, 40)
            stacked[:, :, 0:24] = view0
            stacked[:, :, 24:48] = view1
            stacked[:, :, 48:72] = view2
            return stacked
    raise FileNotFoundError(f"Latents not found for {episode_id}")


def normalize_states(states_7d, stat_path):
    """Normalize 7D states to [-1, 1] using dataset statistics."""
    with open(stat_path) as f:
        stat = json.load(f)
    p01 = np.array(stat["state_01"])
    p99 = np.array(stat["state_99"])
    normalized = 2 * (states_7d - p01) / (p99 - p01 + 1e-8) - 1
    return np.clip(normalized, -1, 1)


def decode_latents(latents, pipeline, decode_chunk_size=7):
    """Decode (B, F, 4, H, W) latents → (B, F, H*8, W*8, 3) uint8."""
    bsz, frame_num = latents.shape[:2]
    flat = latents.flatten(0, 1)
    decoded = []
    for i in range(0, flat.shape[0], decode_chunk_size):
        chunk = flat[i : i + decode_chunk_size] / pipeline.vae.config.scaling_factor
        decoded.append(pipeline.vae.decode(chunk, num_frames=chunk.shape[0]).sample)
    video = torch.cat(decoded, dim=0)
    video = video.reshape(bsz, frame_num, *video.shape[1:])
    video = ((video / 2.0 + 0.5).clamp(0, 1) * 255)
    return video.to(torch.float32).detach().cpu().numpy().transpose(0, 1, 3, 4, 2).astype(np.uint8)


def run_world_model_inference(
    model, pipeline, latents, states_norm, text, args, device,
    start_frame=0,
):
    """Run Ctrl-World inference for 16 frames from start_frame.

    Args:
        model: CrtlWorld model
        pipeline: SVD pipeline (for decoding)
        latents: (T, 4, 72, 40) full episode stacked latents
        states_norm: (T, 7) normalized absolute EE states
        text: task instruction string
        args: wm_args config
        device: torch device
        start_frame: which frame to start from

    Returns:
        pred_frames: (16, H, W, 3) predicted agentview frames
        gt_frames: (17, H, W, 3) ground truth agentview frames
    """
    num_history = args.num_history  # 1
    num_frames = args.num_frames   # 16

    # Extract window: [history, current, future...]
    his_idx = max(0, start_frame - 1)
    window_end = min(start_frame + num_frames + 1, latents.shape[0])
    window_latents = latents[his_idx:window_end].unsqueeze(0).to(device)  # (1, <=17, 4, 72, 40)

    # Pad if needed
    actual_len = window_latents.shape[1]
    if actual_len < num_history + num_frames:
        pad = torch.zeros(1, num_history + num_frames - actual_len, 4, 72, 40, device=device)
        window_latents = torch.cat([window_latents, pad], dim=1)

    his_latent = window_latents[:, :num_history]
    future_latent = window_latents[:, num_history:]
    current_latent = future_latent[:, 0]

    # Build action conditioning
    state_start = max(0, start_frame - num_history)
    state_end = min(start_frame + num_frames, states_norm.shape[0])
    action_window = states_norm[state_start:state_end]

    # Pad to num_history + num_frames
    if len(action_window) < num_history + num_frames:
        pad = np.tile(action_window[-1:], (num_history + num_frames - len(action_window), 1))
        action_window = np.concatenate([action_window, pad])
    action_window = action_window[:num_history + num_frames]

    actions = torch.from_numpy(action_window).float().unsqueeze(0).to(device)  # (1, 17, 7)

    # Encode actions + text
    with torch.no_grad():
        action_latent = model.action_encoder(
            actions, [text], model.tokenizer, model.text_encoder,
            frame_level_cond=args.frame_level_cond,
        )

        _, pred_latents = CtrlWorldDiffusionPipeline.__call__(
            pipeline,
            image=current_latent,
            text=action_latent,
            width=args.width,
            height=int(3 * args.height),
            num_frames=args.num_frames,
            history=his_latent,
            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,
            mask=None,
            output_type="latent",
            return_dict=False,
            frame_level_cond=args.frame_level_cond,
            his_cond_zero=args.his_cond_zero,
        )

    # Split views and decode agentview only
    pred_split = einops.rearrange(pred_latents, "b f c (m h) (n w) -> (b m n) f c h w", m=3, n=1)
    gt_full = torch.cat([his_latent, future_latent], dim=1)
    gt_split = einops.rearrange(gt_full, "b f c (m h) (n w) -> (b m n) f c h w", m=3, n=1)

    # View 0 = agentview
    pred_agent = pred_split[0:1]   # (1, 16, 4, 24, 40)
    gt_agent = gt_split[0:1]       # (1, 17, 4, 24, 40)

    pred_frames = decode_latents(pred_agent, pipeline)[0]   # (16, 192, 320, 3)
    gt_frames = decode_latents(gt_agent, pipeline)[0]       # (17, 192, 320, 3)

    return pred_frames, gt_frames


def main():
    parser = argparse.ArgumentParser(description="Ctrl-World + Converter full inference")
    parser.add_argument("--ckpt", default="model_ckpt/libero_ctrlworld/checkpoint-20000.pt")
    parser.add_argument("--svd_path", default="checkpoints/svd")
    parser.add_argument("--clip_path", default="checkpoints/clip-vit-base-patch32")
    parser.add_argument("--adapter", default="models/converter_weights/libero_action_adapter.pt")
    parser.add_argument("--stat_path", default="dataset_meta_info/libero/stat.json")
    parser.add_argument("--dataset_dir", default="dataset_example/libero")
    parser.add_argument("--rlds_dir", default="raw_data/modified_libero_rlds")
    parser.add_argument("--suite", default="libero_spatial_no_noops")
    parser.add_argument("--episode", type=int, default=3)
    parser.add_argument("--start_frame", type=int, default=20)
    parser.add_argument("--use_converter", action="store_true",
                        help="Use converter to derive states from delta actions (instead of GT states)")
    parser.add_argument("--output_dir", default="scripts/adapter_samples")
    args_cli = parser.parse_args()

    device = torch.device("cuda:0")

    # 1. Load Ctrl-World model
    print("Loading Ctrl-World model...")
    args = wm_args()
    args.svd_model_path = args_cli.svd_path
    args.clip_model_path = args_cli.clip_path
    model = CrtlWorld(args)
    print(f"  Loading checkpoint: {args_cli.ckpt}")
    state_dict = torch.load(args_cli.ckpt, map_location="cpu")
    model.load_state_dict(state_dict, strict=True)
    model.to(device)
    model.eval()
    pipeline = model.pipeline

    # 2. Load converter
    print("Loading action converter...")
    converter = LiberoActionConverter(device=str(device))
    converter.load_adapter(args_cli.adapter, device=str(device))
    print(f"  Converter loaded: {converter.has_adapter}")

    # 3. Load episode data
    suite_short = args_cli.suite.replace("_no_noops", "")
    print(f"\nLoading episode {args_cli.episode} from {args_cli.suite}")
    states_7d, actions, task_text = load_rlds_episode(args_cli.rlds_dir, args_cli.suite, args_cli.episode)
    T = len(states_7d)
    print(f"  Task: {task_text}")
    print(f"  Episode length: {T} steps")

    # 4. Load preprocessed latents
    episode_id = f"{suite_short}_{args_cli.episode:04d}"
    print(f"  Loading latents for {episode_id}")
    latents = load_episode_latents(args_cli.dataset_dir, episode_id)
    print(f"  Latent shape: {latents.shape}")

    # 5. Get absolute EE states (GT or converter-derived)
    if args_cli.use_converter:
        print("\n  Using CONVERTER to derive states from delta actions")
        initial_state = states_7d[0]
        converted = converter.trajectory(initial_state, actions[:T-1])
        ee_states = converted[:T]
    else:
        print("\n  Using GROUND TRUTH absolute states")
        ee_states = states_7d

    # 6. Normalize states
    states_norm = normalize_states(ee_states, args_cli.stat_path).astype(np.float32)

    # 7. Run world model inference for every 16-frame window
    print(f"\nRunning world model inference...")
    all_pred = []
    all_gt = []
    starts = list(range(1, min(T - 17, 80), 16))

    for start in starts:
        print(f"  Window start={start}")
        pred_frames, gt_frames = run_world_model_inference(
            model, pipeline, latents, states_norm, task_text, args, device,
            start_frame=start,
        )
        all_pred.append(pred_frames)
        all_gt.append(gt_frames[1:])  # skip history frame

    # 8. Save comparison video
    os.makedirs(args_cli.output_dir, exist_ok=True)

    mode = "converter" if args_cli.use_converter else "gt_states"
    for i, (pred, gt) in enumerate(zip(all_pred, all_gt)):
        n_frames = min(pred.shape[0], gt.shape[0])
        comparison = np.concatenate([gt[:n_frames], pred[:n_frames]], axis=1)  # stack vertically
        out_path = os.path.join(args_cli.output_dir,
                                f"wm_inference_{suite_short}_ep{args_cli.episode}_{mode}_win{i}.mp4")
        mediapy.write_video(out_path, comparison, fps=4)

    # 9. Save a summary grid image
    import matplotlib
    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    n_windows = len(all_pred)
    fig, axes = plt.subplots(n_windows, 5, figsize=(20, 4 * n_windows))
    if n_windows == 1:
        axes = axes[np.newaxis, :]

    for row, (pred, gt) in enumerate(zip(all_pred, all_gt)):
        for col, t in enumerate([0, 3, 7, 11, 15]):
            if t < pred.shape[0] and t < gt.shape[0] - 1:
                combined = np.concatenate([gt[t + 1], pred[t]], axis=0)
                axes[row, col].imshow(combined)
            axes[row, col].set_title(f"Win {row} t={t}\nGT(top) Pred(bot)", fontsize=9)
            axes[row, col].axis("off")

    fig.suptitle(f"Ctrl-World Inference: {task_text[:60]}\nMode: {mode} | Checkpoint: {os.path.basename(args_cli.ckpt)}",
                 fontsize=13, fontweight="bold")
    plt.tight_layout()
    summary_path = os.path.join(args_cli.output_dir,
                                f"wm_inference_{suite_short}_ep{args_cli.episode}_{mode}_summary.png")
    plt.savefig(summary_path, dpi=150, bbox_inches="tight")
    print(f"\nSaved summary: {summary_path}")
    print(f"Saved {n_windows} comparison videos to {args_cli.output_dir}/")


if __name__ == "__main__":
    main()