code/make_splits.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
make_splits.py —— 按 leg 整体留出的 train / val 划分

为什么不能用训练脚本自带的哈希划分（train.py 的 --val_frac 默认 0.02）：
    clip 步长 84 帧、clip 本身 81 帧 —— 相邻两个 clip 只差 3 帧，画面几乎一样。
    再加上 BOT 在小范围绕圈（straightness 只有 0.10–0.12），按文件名哈希逐个切，
    会把同一段素材的相邻窗口分到训练和验证两边，val 指标直接失真。
    所以：起训必须传 --val_frac 0，val 走这里产出的离线 val_eybx。

划分单位是 **leg**（一次传送到下一次传送之间的整段漫游），不是 clip：
    val    整条 leg 进验证集
    buffer 与 val leg 在时间上紧邻的若干 leg，两边都不进 —— 防止跨 leg 的时间泄漏
    train  其余

转场语料另算：留出 pair 的 clip 只进 pool_heldout（组合泛化评测的 GT 参照），
不进 train。

产出（软链，不复制，省 75 GB）：
    latent/train_eybx/  latent/val_eybx/  latent/pool_heldout/   + splits.json
"""
from __future__ import annotations

import argparse
import glob
import json
import os
import random
from collections import defaultdict

import torch


def link(src, dst_dir):
    dst = os.path.join(dst_dir, os.path.basename(src))
    if os.path.lexists(dst):
        os.remove(dst)
    os.symlink(os.path.abspath(src), dst)


def main():
    ap = argparse.ArgumentParser(description="按 leg 留出的 train/val 划分")
    ap.add_argument("--root", default="/data/zhiyangdeng/data_eybx")
    ap.add_argument("--val_frac", type=float, default=0.055, help="每个 session 的验证集比例")
    ap.add_argument("--buffer_legs", type=int, default=16, help="每个 session 的缓冲 leg 数")
    ap.add_argument("--seed", type=int, default=7)
    args = ap.parse_args()
    rng = random.Random(args.seed)

    pool = os.path.join(args.root, "latent", "pool")
    files = sorted(glob.glob(os.path.join(pool, "clip_*.pt")))
    if not files:
        raise SystemExit(f"[错误] {pool} 是空的，先跑 encode_latents.py")

    # 读每个 latent 的归属（session / leg / 是否转场留出）
    by_leg = defaultdict(list)
    trans_held, trans_train = [], []
    for f in files:
        d = torch.load(f, map_location="cpu", weights_only=False)
        if d.get("session") == "transition":
            (trans_held if d.get("heldout") else trans_train).append(f)
        else:
            by_leg[(d["session"], d["leg"])].append(f)

    out = {k: os.path.join(args.root, "latent", k)
           for k in ("train_eybx", "val_eybx", "pool_heldout")}
    for p in out.values():
        os.makedirs(p, exist_ok=True)
        for old in glob.glob(os.path.join(p, "clip_*.pt")):
            os.remove(old)

    summary = {}
    n_train = n_val = 0
    for sid in sorted({k[0] for k in by_leg}):
        legs = sorted(k[1] for k in by_leg if k[0] == sid)
        counts = {L: len(by_leg[(sid, L)]) for L in legs}
        total = sum(counts.values())
        target = total * args.val_frac
        order = legs[:]; rng.shuffle(order)
        val_legs, got = [], 0
        for L in order:
            if got >= target:
                break
            val_legs.append(L); got += counts[L]
        val_legs = sorted(val_legs)
        # 缓冲：与 val leg 时间相邻（leg 号 ±1）的 leg，两边都不要
        adj = set()
        for L in val_legs:
            adj |= {L - 1, L + 1}
        buf = sorted((adj - set(val_legs)) & set(legs))[:args.buffer_legs]

        v = t = b = 0
        for L in legs:
            fs = by_leg[(sid, L)]
            if L in val_legs:
                for f in fs: link(f, out["val_eybx"])
                v += len(fs)
            elif L in buf:
                b += len(fs)
            else:
                for f in fs: link(f, out["train_eybx"])
                t += len(fs)
        n_train += t; n_val += v
        summary[sid] = dict(clips=total, train=t, val=v, buffer=b,
                            val_frac=round(v / max(total, 1), 4),
                            val_legs=len(val_legs), buffer_legs=len(buf))
        print(f"  {sid}: {total:,} clips -> train {t:,} / val {v:,} / buffer {b:,} "
              f"(val {100*v/max(total,1):.2f}%, val_legs {len(val_legs)}, buffer_legs {len(buf)})")

    for f in trans_train:
        link(f, out["train_eybx"]); n_train += 1
    for f in trans_held:
        link(f, out["pool_heldout"])
    print(f"  转场：训练 {len(trans_train):,} / 留出 {len(trans_held):,}")
    print(f"\n合计 train {n_train:,} · val {n_val:,} · pool {len(files):,} "
          f"· pool_heldout {len(trans_held):,}")

    with open(os.path.join(args.root, "latent", "splits.json"), "w", encoding="utf-8") as fh:
        json.dump(dict(per_session=summary, train=n_train, val=n_val, pool=len(files),
                       heldout=len(trans_held), transition_train=len(trans_train),
                       val_frac=args.val_frac, buffer_legs=args.buffer_legs,
                       note="起训必须传 --val_frac 0；val 走 val_eybx"), fh,
                  ensure_ascii=False, indent=1)
    print("\nDONE  起训记得传 --val_frac 0")


if __name__ == "__main__":
    main()