Helios/_DEV3/tools/visualize_token_match_frames.py

#!/usr/bin/env python3
import argparse
from pathlib import Path

import numpy as np
import torch
from diffusers.models import AutoencoderKLWan
from PIL import Image, ImageDraw, ImageFont

from helios.utils.token_dynamics_debug import token_rect_on_image, token_yx_from_index


def parse_tokens(value: str, grid_w: int):
    tokens = []
    for item in value.split(","):
        item = item.strip()
        if not item:
            continue
        if ":" in item:
            y, x = item.split(":", 1)
            tokens.append(int(y) * grid_w + int(x))
        else:
            tokens.append(int(item))
    return tokens


def decode_latent_frame(vae, latent_frame: torch.Tensor, latents_mean, latents_std):
    latent = latent_frame.unsqueeze(0).unsqueeze(2).to(vae.dtype)
    latent = latent / latents_std + latents_mean
    with torch.no_grad():
        video = vae.decode(latent, return_dict=False)[0]
    frame = video[0, :, 0].float().permute(1, 2, 0).cpu().numpy()
    frame = np.clip((frame + 1.0) / 2.0, 0.0, 1.0)
    return (frame * 255.0).astype(np.uint8)


def to_pil(image_np: np.ndarray) -> Image.Image:
    return Image.fromarray(image_np)


def draw_token_pair(
    history_img: Image.Image,
    noise_img: Image.Image,
    noise_idx: int,
    hist_idx: int,
    score: float,
    grid_h: int,
    grid_w: int,
) -> Image.Image:
    ny, nx = token_yx_from_index(noise_idx, grid_w)
    hy, hx = token_yx_from_index(hist_idx, grid_w)

    hh, hw = history_img.height, history_img.width
    nh, nw = noise_img.height, noise_img.width

    hx0, hy0, hw_box, hh_box = token_rect_on_image(hy, hx, hh, hw, grid_h, grid_w)
    nx0, ny0, nw_box, nh_box = token_rect_on_image(ny, nx, nh, nw, grid_h, grid_w)

    canvas = Image.new("RGB", (hw + nw, max(hh, nh)))
    canvas.paste(history_img, (0, 0))
    canvas.paste(noise_img, (hw, 0))

    draw = ImageDraw.Draw(canvas)
    hist_rect = [hx0, hy0, hx0 + hw_box, hy0 + hh_box]
    noise_rect = [hw + nx0, ny0, hw + nx0 + nw_box, ny0 + nh_box]

    draw.rectangle(hist_rect, outline=(0, 255, 255), width=3)
    draw.rectangle(noise_rect, outline=(0, 255, 0), width=3)

    try:
        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 14)
    except OSError:
        font = ImageFont.load_default()

    draw.text((hx0 + 2, max(0, hy0 - 16)), f"hist ({hy},{hx}) cos={score:.3f}", fill=(0, 255, 255), font=font)
    draw.text((hw + nx0 + 2, max(0, ny0 - 16)), f"noise ({ny},{nx})", fill=(0, 255, 0), font=font)

    return canvas


def main():
    parser = argparse.ArgumentParser(
        description="Save one left-right image per noise token: history frame | noise frame 0."
    )
    parser.add_argument("input", help="token_dynamics_*.pt artifact")
    parser.add_argument("--model-path", default="./checkpoints/Helios-Base")
    parser.add_argument("--output-dir", default=None)
    parser.add_argument(
        "--tokens",
        default="",
        help='Optional subset: comma-separated token ids or "y:x" pairs. Default: all noise tokens.',
    )
    parser.add_argument("--stride", type=int, default=1, help="Use every N-th token when --tokens is empty.")
    args = parser.parse_args()

    artifact = torch.load(args.input, map_location="cpu")
    if artifact.get("noise_latent_frame") is None or artifact.get("history_latent_frame") is None:
        raise RuntimeError(
            "Artifact has no latent frames (expected fully denoised frames saved after chunk sampling). "
            "Re-run inference with updated _DEV3 debug code."
        )

    output_dir = Path(args.output_dir or Path(args.input).parent)
    output_dir.mkdir(parents=True, exist_ok=True)
    stem = Path(args.input).stem

    grid_h, grid_w = artifact["grid"]
    grid_tokens = grid_h * grid_w
    match_indices = artifact["match_indices"].long()
    match_scores = artifact["match_scores"].float()

    if args.tokens.strip():
        tokens = parse_tokens(args.tokens, grid_w)
    else:
        tokens = list(range(0, grid_tokens, args.stride))

    vae = AutoencoderKLWan.from_pretrained(args.model_path, subfolder="vae", torch_dtype=torch.float32)
    latents_mean = torch.tensor(vae.config.latents_mean).view(vae.config.z_dim, 1, 1)
    latents_std = 1.0 / torch.tensor(vae.config.latents_std).view(vae.config.z_dim, 1, 1)

    history_img = to_pil(decode_latent_frame(vae, artifact["history_latent_frame"], latents_mean, latents_std))
    noise_img = to_pil(decode_latent_frame(vae, artifact["noise_latent_frame"], latents_mean, latents_std))

    pair_dir = output_dir / f"{stem}_match_frames"
    pair_dir.mkdir(parents=True, exist_ok=True)

    for noise_idx in tokens:
        hist_idx = int(match_indices[noise_idx].item())
        score = float(match_scores[noise_idx].item())
        ny, nx = token_yx_from_index(noise_idx, grid_w)
        canvas = draw_token_pair(history_img, noise_img, noise_idx, hist_idx, score, grid_h, grid_w)
        out = pair_dir / f"noise{ny:02d}_{nx:02d}.png"
        canvas.save(out)

    print(f"Saved {len(tokens)} images to {pair_dir}")


if __name__ == "__main__":
    main()