code/encode_latents.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
encode_latents.py —— clip mp4 -> Wan2.2 VAE latent

产出 latent/pool/clip_Eybx_<fight>_<start>.pt：
    latent            bf16 [48, 21, 30, 52]   (Wan2.2 TI2V VAE: 16x 空间 / 4x 时间)
    prompts           list[str] 21 条         逐 cell 完整 prompt
    prompts_bossdrop  list[str] 21 条         场景 dropout（只剩动作从句）
    boss/fight/start_cell/video_t0 + 逐 cell 场景/纯度/亮度等 sidecar

key 名沿用 GameMaster 训练侧的契约（gamemaster/data/precomputed.py 直接读
latent / prompts / prompts_bossdrop + 同目录的 text_table.pt）。EYBX 没有 boss，
"bossdrop" 这一路在这里是**场景 dropout**：把场景从句整条去掉，只留动作。
9 个动作 -> 9 个裸串，正好对上旧交付 text_table 的 bare:9。
"""
from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
import time

import numpy as np
import torch
from queue import Queue
from threading import Thread

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, "/nfs/zhiyangdeng/Incantation/wan")      # 只读：modules.vae2_2
from scenes import ACTIONS, SCENE_NL, PROMPT_TMPL           # noqa: E402

W, H, FRAMES = 832, 480, 81
VAE_PTH = "/data/zhiyangdeng/AWS/assets/Wan2.2_VAE.pth"
BARE_TMPL = "In a 2.5D top down view, the player is {action}."


def bare_prompt(action_idx: int) -> str:
    return BARE_TMPL.format(action=ACTIONS[action_idx])


def read_clip(path: str) -> np.ndarray | None:
    raw = subprocess.run(
        ["ffmpeg", "-v", "error", "-i", path, "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
        capture_output=True).stdout
    n = len(raw) // (W * H * 3)
    if n < FRAMES:
        return None
    return np.frombuffer(raw[:FRAMES * W * H * 3], np.uint8).reshape(FRAMES, H, W, 3)


def main():
    ap = argparse.ArgumentParser(description="VAE 编码")
    ap.add_argument("--root", default="/data/zhiyangdeng/data_eybx")
    ap.add_argument("--sessions", nargs="*",
                    default=["20260821_190601_787", "20260823_201942_753"])
    ap.add_argument("--out", default=None, help="默认 <root>/latent/pool")
    ap.add_argument("--vae_pth", default=VAE_PTH)
    ap.add_argument("--device", default="cuda")
    ap.add_argument("--limit", type=int, default=None)
    ap.add_argument("--shard", type=int, default=0)
    ap.add_argument("--nshard", type=int, default=1)
    ap.add_argument("--prefetch", type=int, default=8,
                    help="预取队列深度；每个已解码 clip 约 97 MB，别调大")
    ap.add_argument("--decoders", type=int, default=4, help="解码线程数")
    args = ap.parse_args()

    out = args.out or os.path.join(args.root, "latent", "pool")
    os.makedirs(out, exist_ok=True)

    rows = []
    for sid in args.sessions:
        p = os.path.join(args.root, "meta", f"{sid}.jsonl")
        with open(p, encoding="utf-8") as fh:
            for line in fh:
                rows.append(json.loads(line))
    rows.sort(key=lambda r: r["clip_id"])
    rows = rows[args.shard::args.nshard]
    if args.limit:
        rows = rows[:args.limit]
    print(f"{len(rows):,} 个 clip 待编码 (shard {args.shard}/{args.nshard}) -> {out}", flush=True)

    from modules.vae2_2 import Wan2_2_VAE
    vae = Wan2_2_VAE(vae_pth=args.vae_pth, device=args.device)

    # 解码（CPU）与编码（GPU）重叠。这里必须是【有界】的生产者-消费者：
    # 一个解码好的 clip 是 81x480x832x3 = 97 MB，如果解码线程不受限地跑在
    # GPU 前面，内存会以每秒数百 MB 的速度堆积（实测跑成单进程 637 GB RSS，
    # 在共用机器上会把别人一起拖垮）。输出队列有上限，解码线程 put 时阻塞，
    # 于是在途的解码结果最多 prefetch + decoders 个 ≈ 2 GB。
    todo = [r for r in rows if not os.path.exists(os.path.join(out, r["clip_id"] + ".pt"))]
    skipped = len(rows) - len(todo)
    q: Queue = Queue(maxsize=args.prefetch)
    jobs: Queue = Queue()
    for r in todo:
        jobs.put(r)
    for _ in range(args.decoders):
        jobs.put(None)

    def decoder():
        while True:
            r = jobs.get()
            if r is None:
                break
            q.put((r, read_clip(os.path.join(args.root, "clips", r["session"],
                                             r["clip_id"] + ".mp4"))))

    threads = [Thread(target=decoder, daemon=True) for _ in range(args.decoders)]
    for t in threads:
        t.start()

    def closer():
        for t in threads:
            t.join()
        q.put((None, None))

    Thread(target=closer, daemon=True).start()

    t0 = time.time(); done = 0; failed = 0
    i = -1
    while True:
        r, pix = q.get()
        if r is None:
            break
        i += 1
        dst = os.path.join(out, r["clip_id"] + ".pt")
        if pix is None:
            failed += 1
            continue
        # [F,H,W,3] uint8 -> [3,F,H,W] float in [-1,1]
        x = torch.from_numpy(pix.copy()).permute(3, 0, 1, 2).float().div_(127.5).sub_(1.0)
        with torch.no_grad():
            lat = vae.encode([x.to(args.device)])[0].to(torch.bfloat16).cpu()
        assert lat.shape[0] == 48 and lat.shape[1] == 21, f"latent 形状异常 {tuple(lat.shape)}"
        # 基础 clip 与转场 clip 的 sidecar 字段不同，统一用 get 取，缺的就不写。
        rec = {
            "latent": lat,
            "prompts": r["prompts"],
            "prompts_bossdrop": [bare_prompt(a) for a in r["actions"]],
            "boss": "Eybx", "fight": r["fight"], "start_cell": r["start_cell"],
            "session": r["session"],
            "scenes": r["scenes"], "actions": r["actions"],
            "min_purity": r.get("min_purity"),
        }
        for k in ("video_t", "log_vt", "offset", "seg_id", "leg", "purity",
                  "lum", "rt_ratio", "region", "speed_med", "x", "z",
                  "kind", "pair", "n_pre", "n_burn", "burn_cells", "heldout",
                  "src_a", "src_b", "action"):
            if k in r:
                rec["video_t0" if k == "video_t" else k] = r[k]
        torch.save(rec, dst)
        done += 1
        if done % 200 == 0:
            el = time.time() - t0
            print(f"  [{i+1}/{len(todo)}] 已编码 {done:,} · {done/el:.1f} clip/s "
                  f"· ETA {(len(todo)-i-1)/max(done/el,1e-9)/60:.1f} min", flush=True)
    print(f"DONE  新编码 {done:,} · 跳过已存在 {skipped:,} · 失败 {failed:,}"
          f" · 用时 {(time.time()-t0)/60:.1f} min")


if __name__ == "__main__":
    main()