code/gate_latents.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
gate_latents.py —— 起训前的五项闸门

刻意【不 import 任何产线代码】。闸门的价值在于用另一条独立路径复算同一件事；
一旦它调用产线里的函数，产线的 bug 就会同时出现在两边而闸门照样放行。
所以这里的形状、计数、覆盖全部直接从 .pt 文件自己读、自己算。

  1. 形状与 prompts 长度   全部 [48,21,30,52] bf16，prompts / prompts_bossdrop 各 21 条
  2. 逐 latent 帧间差       抓「同一帧被复制 81 次」这类静默失败：帧间差趋近 0
  3. 逐类计数对账           base / burn / hardcut 数量与号段，且无撞名
  4. 文本表覆盖             池里每个串都要能在表里查到，缺一个训练就会中途 KeyError
  5. 留出 pair 泄漏         训练池里不得出现留出组合的 clip
"""
from __future__ import annotations

import argparse
import glob
import json
import os
import random

import torch

EXPECT_SHAPE = (48, 21, 30, 52)
EXPECT_CELLS = 21
DIFF_FLOOR = 0.02          # 帧间差底线；低于此基本可以断定是复制帧
SEG_BASE = {100_000_000: "base_s1", 200_000_000: "base_s2",
            300_000_000: "burn", 400_000_000: "hardcut"}


def seg_of(fight: int) -> str:
    for b in sorted(SEG_BASE, reverse=True):
        if fight >= b:
            return SEG_BASE[b]
    return "unknown"


def gate(name, ok, detail):
    print(f"  [{'通过' if ok else '不通过'}] {name}\n        {detail}")
    return ok


def main():
    ap = argparse.ArgumentParser(description="latent 闸门")
    ap.add_argument("--latent", default="/data/zhiyangdeng/data_eybx/latent/pool")
    ap.add_argument("--text_table", default="/data/zhiyangdeng/data_eybx/latent/text_table_eybx.pt")
    ap.add_argument("--heldout", default="/data/zhiyangdeng/data_eybx/latent/heldout_pairs.json")
    ap.add_argument("--train", default="/data/zhiyangdeng/data_eybx/latent/train_eybx")
    ap.add_argument("--sample_diff", type=int, default=3000, help="第 2 项抽查多少个")
    ap.add_argument("--seed", type=int, default=7)
    args = ap.parse_args()

    files = sorted(glob.glob(os.path.join(args.latent, "clip_*.pt")))
    print(f"池：{len(files):,} 个 latent  ({args.latent})\n")
    if not files:
        raise SystemExit("[错误] 池是空的")
    rng = random.Random(args.seed)
    allok = True

    # ---- 1 形状与 prompts 长度 ----
    bad_shape, bad_prompt, counts, names = [], [], {}, {}
    prompts_seen = set()
    for f in files:
        d = torch.load(f, map_location="cpu", weights_only=False)
        lat = d["latent"]
        if tuple(lat.shape) != EXPECT_SHAPE or lat.dtype != torch.bfloat16:
            bad_shape.append((os.path.basename(f), tuple(lat.shape), str(lat.dtype)))
        if len(d["prompts"]) != EXPECT_CELLS or len(d["prompts_bossdrop"]) != EXPECT_CELLS:
            bad_prompt.append((os.path.basename(f),
                               len(d["prompts"]), len(d["prompts_bossdrop"])))
        s = seg_of(int(d["fight"]))
        counts[s] = counts.get(s, 0) + 1
        stem = os.path.basename(f)[:-3]
        names.setdefault(stem, []).append(f)
        prompts_seen.update(d["prompts"]); prompts_seen.update(d["prompts_bossdrop"])
    allok &= gate("形状与 prompts 长度",
                  not bad_shape and not bad_prompt,
                  f"全部 {EXPECT_SHAPE} bf16，prompts / prompts_bossdrop 各 {EXPECT_CELLS} 条。"
                  f"形状不合格 {len(bad_shape)}，长度不合格 {len(bad_prompt)}。"
                  + (f" 例：{bad_shape[:2] or bad_prompt[:2]}" if bad_shape or bad_prompt else ""))

    # ---- 2 逐 latent 帧间差 ----
    samp = rng.sample(files, min(args.sample_diff, len(files)))
    mins = []
    for f in samp:
        lat = torch.load(f, map_location="cpu", weights_only=False)["latent"].float()
        d1 = (lat[:, 1:] - lat[:, :-1]).abs().mean(dim=(0, 2, 3))
        mins.append(float(d1.min()))
    mins.sort()
    lo = mins[0]; p1 = mins[max(0, len(mins) // 100)]; med = mins[len(mins) // 2]
    n_bad = sum(1 for m in mins if m < DIFF_FLOOR)
    allok &= gate("逐 latent 帧间差 —— 无复制帧", n_bad == 0,
                  f"抽查 {len(samp):,} 个：最小 {lo:.4f}、p1 {p1:.4f}、中位 {med:.4f}。"
                  f"底线 {DIFF_FLOOR}，低于底线 {n_bad} 个 —— 离底线有 {lo/DIFF_FLOOR:.1f} 倍余量。")

    # ---- 3 逐类计数对账 ----
    dup = {k: v for k, v in names.items() if len(v) > 1}
    allok &= gate("逐类计数对账", not dup,
                  " / ".join(f"{k}:{v:,}" for k, v in sorted(counts.items()))
                  + f"；撞名 {len(dup)} 个。")

    # ---- 4 文本表覆盖 ----
    if os.path.exists(args.text_table):
        table = torch.load(args.text_table, map_location="cpu", weights_only=False)
        missing = sorted(prompts_seen - set(table))
        unused = sorted(set(table) - prompts_seen)
        allok &= gate("文本表覆盖", not missing,
                      f"池里 {len(prompts_seen):,} 个不同串，表 {len(table):,} 键，"
                      f"缺 {len(missing)}。未用的 {len(unused)} 个。"
                      + (f" 缺失例：{missing[:2]}" if missing else ""))
    else:
        allok &= gate("文本表覆盖", False, f"找不到文本表 {args.text_table}")

    # ---- 5 留出 pair 泄漏 ----
    if os.path.exists(args.heldout) and os.path.isdir(args.train):
        ho = json.load(open(args.heldout, encoding="utf-8"))
        ho_pairs = {tuple(p) for p in ho["pairs"]}
        leak = 0
        for f in sorted(glob.glob(os.path.join(args.train, "clip_*.pt"))):
            d = torch.load(f, map_location="cpu", weights_only=False)
            pr = d.get("pair")
            if pr and tuple(pr) in ho_pairs:
                leak += 1
        allok &= gate("留出 pair 泄漏", leak == 0,
                      f"训练池里来自留出 {len(ho_pairs)} 对的 clip：{leak}。")
    else:
        print("  [跳过] 留出 pair 泄漏：转场语料尚未生成")

    print(f"\n{'五项全过' if allok else '有闸门未通过 —— 不要起训'}")
    raise SystemExit(0 if allok else 1)


if __name__ == "__main__":
    main()