#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ burn_corpus.py —— 转场语料：把两个不同场景的 clip 烧成一个新的 81 帧 clip 目的不是做特效，是训一个**可触发的换场景开关**：推理时把场景从句换成 trigger 从句、握持几个 cell，模型就烧向指定的新场景。 四条硬约束（缺一条这个开关就训不出来）： 1. trigger 从句里**必须含目的地** —— 否则没法指定转到哪个场景 2. 燃烧的起止必须踩 latent cell 边界 —— (N_pre-1)%4==0、N_burn ∈ {8,12,16} cell k 覆盖帧 4k-3..4k，燃烧不踩边界的话某个 cell 会同时含 A 和火， 那个 cell 的文本条件就无法定义 3. N_pre 在样本间随机 —— 固定的话模型会把「烧」绑到时间位置而不是绑到 prompt 4. 烧完切回纯 B 动作从句全程不变：所以只挑「21 个 cell 动作恒定」的 clip，且 A、B 的动作相同。 这正是要用动作真值对齐接缝的原因 —— 接缝两侧玩家的运动方向必须一致， 否则烧完的瞬间画面会出现一个物理上不可能的转向。 hardcut 是负对照（"cutting to"，瞬切无火），教模型 trigger 词本身 ≠ 火。 火焰合成直接用 burn_transition.py 的实现（极坐标湍流火口 + 焦化 + 热浪 + 四层火焰）， 只是把它从「读两个视频文件」改成「吃内存里的两段帧」。 """ from __future__ import annotations import argparse import json import os import random import subprocess import sys import numpy as np sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) sys.path.insert(0, "/data/zhiyangdeng") # burn_transition.py from scenes import SCENE_NL, ACTIONS # noqa: E402 import burn_transition as BT # noqa: E402 W, H, FRAMES, CELLS, FPS = 832, 480, 81, 21, 16.0 BURN_BASE, HARDCUT_BASE = 300_000_000, 400_000_000 N_PRE_CHOICES = [9, 13, 17, 21, 25, 29, 33] # 均满足 (N_pre-1)%4==0 N_BURN_CHOICES = [8, 12, 16] # 2 / 3 / 4 个 cell # 场景从句统一是 "in a ..." 开头，直接套进 "burning away into {b}" 会拼出 # "...burning away into in a dark cave..."。目的地要去掉前导的 "in "， # 只留名词短语，才读得通。 TRIG_BURN = "In a 2.5D top down view, {a} burning away into {b}, the player is {action}." TRIG_CUT = "In a 2.5D top down view, {a} cutting to {b}, the player is {action}." def np_of(clause: str) -> str: """场景从句 -> 名词短语：只去掉前导的 "in "，冠词要留着。 "in a dark cave lit by blue crystal glow" -> "a dark cave lit by blue crystal glow" """ return clause[3:] if clause.startswith("in ") else clause PLAIN = "In a 2.5D top down view, {s}, the player is {action}." def cell_of(frame_idx: int) -> int: """帧 -> latent cell（cell 0 = 帧 0；cell k = 帧 4k-3..4k）。""" return 0 if frame_idx == 0 else (frame_idx + 3) // 4 def read_clip(path): 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 encode(frames, path, crf=18): p = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{W}x{H}", "-r", f"{FPS:g}", "-i", "-", "-an", "-c:v", "libx264", "-crf", str(crf), "-preset", "veryfast", "-pix_fmt", "yuv420p", "-movflags", "+faststart", path], stdin=subprocess.PIPE) p.stdin.write(np.ascontiguousarray(frames).tobytes()) p.stdin.close() return p.wait() == 0 def compose_burn(fa, fb, n_pre, n_burn, seed, amp=110.0, embers=1.0, color="fire"): """fa/fb: [81,H,W,3] RGB uint8。返回烧接后的 [81,H,W,3]。""" rng = np.random.default_rng(seed) cx, cy = 0.5 * W, 0.5 * H yy, xx = np.mgrid[0:H, 0:W].astype(np.float32) dxg, dyg = xx - cx, yy - cy dist = np.hypot(dxg, dyg) rmax = float(dist.max()) noise = BT.PolarNoise(dist, np.arctan2(dyg, dxg), rmax, rng) emb = BT.Embers(W, H, cx, cy, rng) C_HOT, C_MID, C_OUT, C_GLOW = (np.array(c, np.float32) for c in BT.PALETTES[color]) cfg = BT.Config(a="", b="", out="", amp=amp, embers=embers, style="burn", color=color) out = np.empty((FRAMES, H, W, 3), np.uint8) out[:n_pre] = fa[:n_pre] prev_r = 0.0 for k in range(n_burn): i = n_pre + k # BGR：burn_transition 的配色是 BGR 序，这里整段在 BGR 域里算完再转回来 A = fa[i][:, :, ::-1].astype(np.float32) B = fb[i][:, :, ::-1].astype(np.float32) u = (k + 1) / n_burn img, r = BT._composite_burn(A, B, dist, dxg, dyg, xx, yy, rmax, u, k, cfg, noise, rng, C_HOT, C_MID, C_OUT, C_GLOW) fade = 1.0 - BT.smoothstep((r - rmax * 0.90) / (rmax * 0.22)) emb.spawn(int(160 * embers * fade * (0.4 + 0.6 * min(r / 200.0, 1.0))), max(r, 6.0), max(r - prev_r, 0.0)) emb.step() import cv2 sp = cv2.GaussianBlur(emb.draw(), (0, 0), 0.7) big = cv2.GaussianBlur(sp, (0, 0), 5.0) * 0.60 img = img + (C_HOT * (np.clip(sp, 0, 2.6) * 0.75)[..., None] + C_MID * (np.clip(sp, 0, 2.6) * 1.05)[..., None] + C_OUT * big[..., None]) prev_r = r out[i] = np.clip(img, 0, 255).astype(np.uint8)[:, :, ::-1] # 烧完切回纯 B（余烬只留很短一截，避免污染 B 的场景条件） import cv2 for i in range(n_pre + n_burn, FRAMES): img = fb[i][:, :, ::-1].astype(np.float32) if len(emb) and i - (n_pre + n_burn) < 8: emb.step() sp = cv2.GaussianBlur(emb.draw(), (0, 0), 1.2) img = img + C_MID * (np.clip(sp, 0, 2.2) * 0.95)[..., None] out[i] = np.clip(img, 0, 255).astype(np.uint8)[:, :, ::-1] return out def prompt_schedule(sa, sb, action, n_pre, n_burn, trig_tmpl): """21 条逐 cell prompt：A 场景 -> trigger(含目的地) -> B 场景。""" c0 = cell_of(n_pre) # 燃烧起始 cell c1 = cell_of(n_pre + n_burn - 1) # 燃烧结束 cell（含） act = ACTIONS[action] ps = [] for k in range(CELLS): if k < c0: ps.append(PLAIN.format(s=SCENE_NL[sa], action=act)) elif k <= c1: ps.append(trig_tmpl.format(a=SCENE_NL[sa], b=np_of(SCENE_NL[sb]), action=act)) else: ps.append(PLAIN.format(s=SCENE_NL[sb], action=act)) return ps, c0, c1 def hamiltonian_pairs(scenes, rng): """18 个场景的哈密顿圈：每个场景各当一次源、一次目的地。""" s = list(scenes); rng.shuffle(s) return [(s[i], s[(i + 1) % len(s)]) for i in range(len(s))] def main(): ap = argparse.ArgumentParser(description="燃烧转场语料") ap.add_argument("--root", default="/data/zhiyangdeng/data_eybx") ap.add_argument("--n_burn", type=int, default=1500) ap.add_argument("--n_hardcut", type=int, default=400) ap.add_argument("--n_dir_pairs", type=int, default=6, help="额外留出的方向对") ap.add_argument("--seed", type=int, default=7) ap.add_argument("--workers", type=int, default=16) args = ap.parse_args() rng = random.Random(args.seed) rows = [] for f in sorted(os.listdir(os.path.join(args.root, "meta"))): if not f.endswith(".jsonl"): continue with open(os.path.join(args.root, "meta", f), encoding="utf-8") as fh: rows += [json.loads(l) for l in fh] # 只用「场景纯 + 动作恒定 + 在动」的 clip：接缝两侧的动作从句必须完全一样 pool = {} for r in rows: # 纯度 >=0.75 就收（旧交付成品里本来就有 min_purity 0.75 的 clip）； # 场景取该 clip 的主场景。要求全程只出现一个场景，接缝才不会把第三个场景带进来。 if r["min_purity"] < 0.75: continue acts = set(r["actions"]); scs = set(r["scenes"]) if len(acts) != 1 or len(scs) != 1: continue a = acts.pop() if a == 0: # 站着不动的接缝没有对齐意义 continue pool.setdefault((scs.pop(), a), []).append(r) scenes = sorted({k[0] for k in pool}) print(f"可用底料 {sum(len(v) for v in pool.values()):,} 个 clip · " f"{len(scenes)} 个场景 · {len(pool)} 个 (场景,动作) 组合") # 留出：18 对哈密顿圈（每场景各当一次源、一次目的地）+ 6 对方向对 held = set(hamiltonian_pairs(scenes, rng)) cand = [(a, b) for a in scenes for b in scenes if a != b and (a, b) not in held and (b, a) not in held] rng.shuffle(cand) dir_pairs = cand[:args.n_dir_pairs] held |= set(dir_pairs) print(f"留出 {len(held)} 对（{len(held)-len(dir_pairs)} 对哈密顿圈 + " f"{len(dir_pairs)} 对方向对，方向对的反向留在训练集里）") out_clips = os.path.join(args.root, "clips", "transition"); os.makedirs(out_clips, exist_ok=True) out_meta = os.path.join(args.root, "meta"); os.makedirs(out_meta, exist_ok=True) def sample_pair(allow_held): for _ in range(400): a, b = rng.sample(scenes, 2) if ((a, b) in held) != allow_held: continue acts = [k[1] for k in pool if k[0] == a] rng.shuffle(acts) for act in acts: if (b, act) in pool and pool[(a, act)] and pool[(b, act)]: return a, b, act return None jobs = [] for i in range(args.n_burn + args.n_hardcut): is_burn = i < args.n_burn # 留出对也要生成 clip，但只进 pool_heldout，不进训练池 allow_held = (i % 12 == 0) got = sample_pair(allow_held) if got is None: got = sample_pair(False) allow_held = False if got is None: continue a, b, act = got ra = rng.choice(pool[(a, act)]); rb = rng.choice(pool[(b, act)]) n_pre = rng.choice(N_PRE_CHOICES) n_bn = rng.choice(N_BURN_CHOICES) base = BURN_BASE if is_burn else HARDCUT_BASE jobs.append(dict(idx=i, kind="burn" if is_burn else "hardcut", a=a, b=b, action=act, ra=ra["clip_id"], rb=rb["clip_id"], sa=ra["session"], sb=rb["session"], n_pre=n_pre, n_burn=n_bn, held=allow_held, fight=base + i, seed=args.seed * 100003 + i)) print(f"计划生成 {len(jobs):,} 条（burn {sum(1 for j in jobs if j['kind']=='burn'):,} / " f"hardcut {sum(1 for j in jobs if j['kind']=='hardcut'):,}，" f"其中留出 {sum(1 for j in jobs if j['held']):,}）") json.dump(dict(pairs=[list(p) for p in sorted(held)], hamiltonian=len(held) - len(dir_pairs), direction=len(dir_pairs)), open(os.path.join(args.root, "latent", "heldout_pairs.json"), "w"), ensure_ascii=False, indent=1) from concurrent.futures import ProcessPoolExecutor, as_completed with open(os.path.join(out_meta, "transition.jsonl"), "w", encoding="utf-8") as fh, \ ProcessPoolExecutor(args.workers) as ex: futs = {ex.submit(_render, j, args.root, out_clips): j for j in jobs} done = 0 for f in as_completed(futs): r = f.result() if r: fh.write(json.dumps(r, ensure_ascii=False) + "\n"); done += 1 if done % 100 == 0 and done: print(f" {done:,}/{len(jobs):,}", flush=True) print(f"DONE {done:,} 条转场 -> {out_clips}") def _render(j, root, out_clips): fa = read_clip(os.path.join(root, "clips", j["sa"], j["ra"] + ".mp4")) fb = read_clip(os.path.join(root, "clips", j["sb"], j["rb"] + ".mp4")) if fa is None or fb is None: return None if j["kind"] == "burn": pix = compose_burn(fa, fb, j["n_pre"], j["n_burn"], j["seed"]) tmpl = TRIG_BURN else: pix = np.concatenate([fa[:j["n_pre"]], fb[j["n_pre"]:]], 0) # 瞬切，无火 tmpl = TRIG_CUT ps, c0, c1 = prompt_schedule(j["a"], j["b"], j["action"], j["n_pre"], j["n_burn"], tmpl) stem = f"clip_Eybx_{j['fight']}_{0:06d}" if not encode(pix, os.path.join(out_clips, stem + ".mp4")): return None return dict(clip_id=stem, session="transition", kind=j["kind"], fight=j["fight"], start_cell=0, pair=[j["a"], j["b"]], action=j["action"], src_a=j["ra"], src_b=j["rb"], n_pre=j["n_pre"], n_burn=j["n_burn"], burn_cells=[c0, c1], heldout=j["held"], prompts=ps, actions=[j["action"]] * CELLS, scenes=[j["a"]] * c0 + [f"{j['a']}->{j['b']}"] * (c1 - c0 + 1) + [j["b"]] * (CELLS - c1 - 1), min_purity=1.0) if __name__ == "__main__": main()