scripts/build_v4.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""天机 v4:按阶段提示词的 SFT 数据。做法照 A1 的 build_stage14_cf.py(按段拆条 + 切点前移抖动 + 切点后“保持”样本)。

输入:v3 格式的 LeRobot 数据集(每帧 action 是预先算好的 30 步 × 20 维动作块,15Hz 真实时间),
      以及 _annotations/<数据集别名>.json 里的 4 段人工切点和“先做哪侧”。
规则:
  * 每条录像按 3 个切点拆成 4 段,每段单独成一条 episode,每帧配该段的提示词:
      第 1 段 “Raise the back wall and press down the top lid.”
      第 2/3 段 按实际先后 “Fold the right side.” / “Fold the left side.”
      第 4 段 “Push the box back into place.”
  * 段尾截断:动作块里超过本段最后一帧时刻的步,换成本段最后一帧的第 0 步动作
    (= A1 里加载器用本段最后一个动作补齐;做完本段、没收到下一段提示词就停住)。
  * 切点抖动(仅训练集):每份数据把每个切点随机往前挪 0..jitter 秒(按本条采样频率换成帧),
    挪出的帧配下一段提示词、动作为录像真实动作。
  * “保持”样本:每个人工切点 b(第 k 段 → 第 k+1 段)之后 cf 秒内的每一帧,单独成一条 1 帧 episode:
    画面与状态取自第 t 帧,提示词 = 第 k 段,动作块 30 步全是 [两臂当前实测末端位姿, 夹爪 = 第 k 段最后的夹爪命令]。
  * 剔除 --drop 指定的条目;--side 覆盖“先做哪侧”;15Hz(新)数据复制 --repeat-new 份(每份抖动独立)。
视频硬链接原数据集的文件,每条 episode 用 from/to 时间指向原视频中的对应片段(数据集 fps 10 是名义值,与 v3 一致)。
用法(104):python build_v4.py --dst <输出> --src <v3 数据集目录> --ann <标注别名> [--drop 41 49] [--side 19=left 51=right] [--val]
"""
import argparse
import glob
import json
import os
import shutil
from pathlib import Path

import numpy as np
import pandas as pd

ANN = Path("/data/yh/tianji_data/_annotations")
CAMS = ["observation.images.cam_high", "observation.images.cam_left_wrist", "observation.images.cam_right_wrist"]
PROMPTS = ["Raise the back wall and press down the top lid.", "Fold the right side.", "Fold the left side.",
           "Push the box back into place."]
H, D = 30, 20                      # 动作块步数、每步维数
STEP_HZ = 15.0                     # 动作块步长(真实时间)
NOMINAL_FPS = 10                   # 数据集名义 fps(视频按此编码)
POSE = [i for a in (0, 10) for i in range(a, a + 9)]   # 两臂 xyz + r6d
GRIP = [9, 19]

ap = argparse.ArgumentParser()
ap.add_argument("--dst", required=True)
ap.add_argument("--src", nargs="+", required=True, help="v3 格式数据集目录(可多个,与 --ann 一一对应)")
ap.add_argument("--ann", nargs="+", required=True, help="标注别名(_annotations/<别名>.json)")
ap.add_argument("--drop", nargs="*", default=[], help="剔除的条目,写成 <别名>:<序号> 或 <序号>(对所有数据集)")
ap.add_argument("--side", nargs="*", default=[], help="覆盖先做哪侧,写成 [<别名>:]<序号>=left|right")
ap.add_argument("--jitter-s", type=float, default=1 / 3, help="切点最多往前挪的秒数")
ap.add_argument("--cf-s", type=float, default=1.0, help="每个切点之后生成保持样本的秒数")
ap.add_argument("--repeat-new", type=int, default=2, help="15Hz 新数据复制份数")
ap.add_argument("--min-frames", type=int, default=5)
ap.add_argument("--frames-per-file", type=int, default=200000)
ap.add_argument("--val", action="store_true", help="验证集:不抖动、不复制")
ap.add_argument("--seed", type=int, default=0)
a = ap.parse_args()
assert len(a.src) == len(a.ann)
dst = Path(a.dst)
if dst.exists():
    raise SystemExit(f"{dst} 已存在,不覆盖")
(dst / "meta" / "episodes" / "chunk-000").mkdir(parents=True)


def parse_sel(items, name, with_value=False):
    out = {}
    for it in items:
        key, _, val = it.partition("=") if with_value else (it, "", "")
        ds, _, ep = key.rpartition(":")
        if ds in ("", name):
            out[int(ep)] = val if with_value else True
    return out


def load_source(src):
    src = Path(src)
    E = pd.concat([pd.read_parquet(f) for f in sorted(glob.glob(str(src / "meta/episodes/chunk-*/*.parquet")))])
    E = E.sort_values("episode_index").set_index("episode_index")
    rep = json.load(open(src / "conversion_report.json"))
    hz = {}
    for e in rep.get("episodes", []):
        hz[int(e["index"])] = float(e.get("source_hz") or 10)
    data, cache = {}, {}
    for ep, r in E.iterrows():
        f = src / ("data/chunk-%03d/file-%03d.parquet" % (r["data/chunk_index"], r["data/file_index"]))
        if f not in cache:
            cache[f] = pd.read_parquet(f, columns=["episode_index", "frame_index", "observation.state", "action"])
        X = cache[f]; X = X[X.episode_index == ep].sort_values("frame_index")
        vids = {c: (src / ("videos/%s/chunk-%03d/file-%03d.mp4" % (c, r["videos/%s/chunk_index" % c], r["videos/%s/file_index" % c])),
                    float(r["videos/%s/from_timestamp" % c])) for c in CAMS}
        data[int(ep)] = dict(state=np.stack(X["observation.state"].values).astype(np.float32),
                             action=np.stack(X["action"].values).astype(np.float32), videos=vids, length=len(X),
                             hz=hz.get(int(ep), 10.0))
    return data


video_map = {}


def link_video(cam, path):
    key = (cam, str(path))
    if key not in video_map:
        n = sum(1 for k in video_map if k[0] == cam); video_map[key] = (n // 1000, n % 1000)
        d = dst / "videos" / cam / ("chunk-%03d" % video_map[key][0]); d.mkdir(parents=True, exist_ok=True)
        os.link(path, d / ("file-%03d.mp4" % video_map[key][1]))
    return video_map[key]


def truncate_at_end(act, s0, s1, hz):
    """act: (n, H*D) 本段各帧动作块;超过本段最后一帧时刻的步换成最后一帧的第 0 步动作。"""
    out = act.reshape(len(act), H, D).copy()
    last = out[-1, 0].copy()
    i = np.arange(s0, s1)
    kmax = np.floor((s1 - 1 - i) / hz * STEP_HZ + 1e-6).astype(int)   # 每帧最后一个仍在段内的步
    mask = np.arange(H)[None, :] > kmax[:, None]
    out[mask] = last
    return out.reshape(len(act), H * D)


rng = np.random.default_rng(a.seed)
ep_rows, buf, report = [], [], []
st_all = {"gidx": 0, "ep": 0, "file": 0, "file_frames": 0}


def flush():
    if not buf:
        return
    p = dst / ("data/chunk-000/file-%03d.parquet" % st_all["file"]); p.parent.mkdir(parents=True, exist_ok=True)
    pd.concat(buf, ignore_index=True).to_parquet(p, index=False); buf.clear()
    st_all["file"] += 1; st_all["file_frames"] = 0


def add_episode(d, s0, s1, task, act, kind, src, stage):
    n = s1 - s0
    if st_all["file_frames"] + n > a.frames_per_file:
        flush()
    g, e = st_all["gidx"], st_all["ep"]
    buf.append(pd.DataFrame({"observation.state": list(d["state"][s0:s1]), "action": list(act.astype(np.float32)),
                             "timestamp": (np.arange(n) / NOMINAL_FPS).astype(np.float32),
                             "frame_index": np.arange(n, dtype=np.int64), "episode_index": np.full(n, e, np.int64),
                             "index": np.arange(g, g + n, dtype=np.int64), "task_index": np.full(n, task, np.int64)}))
    row = {"episode_index": e, "tasks": [PROMPTS[task]], "length": n, "data/chunk_index": 0, "data/file_index": st_all["file"],
           "dataset_from_index": g, "dataset_to_index": g + n}
    for c in CAMS:
        path, frm = d["videos"][c]; vc, vf = link_video(c, path)
        row.update({"videos/%s/chunk_index" % c: vc, "videos/%s/file_index" % c: vf,
                    "videos/%s/from_timestamp" % c: frm + s0 / NOMINAL_FPS, "videos/%s/to_timestamp" % c: frm + s1 / NOMINAL_FPS})
    row.update({"meta/episodes/chunk_index": 0, "meta/episodes/file_index": 0})
    ep_rows.append(row)
    report.append({"kind": kind, "src": src, "from": int(s0), "to": int(s1), "stage": int(stage), "task": int(task), "episode": e})
    st_all["gidx"] += n; st_all["ep"] += 1; st_all["file_frames"] += n


for src_dir, name in zip(a.src, a.ann):
    ann = json.load(open(ANN / f"{name}.json"))["episodes"]
    drop, sides = parse_sel(a.drop, name), parse_sel(a.side, name, with_value=True)
    data = load_source(src_dir)
    st = dict(used=0, dropped=0, unconfirmed=0, bad_cuts=0, seg=0, seg_frames=0, cf=0, jitter_frames=0, skipped_short=0, side_fixed=0)
    for ep_s, rec in sorted(ann.items(), key=lambda x: int(x[0])):
        ep = int(ep_s)
        if ep in drop:
            st["dropped"] += 1; continue
        if not rec.get("confirmed"):
            st["unconfirmed"] += 1; continue
        cuts = list(rec.get("cuts") or [])
        if len(cuts) != 3:
            st["bad_cuts"] += 1; continue
        d = data[ep]; L, hz = d["length"], d["hz"]
        assert rec.get("length") in (None, L), (name, ep, rec.get("length"), L)
        side = sides.get(ep, rec.get("first_side"))
        if ep in sides:
            st["side_fixed"] += 1
        assert side in ("left", "right"), (name, ep, side)
        first, second = (1, 2) if side == "right" else (2, 1)
        tasks = [0, first, second, 3]
        b = [0] + cuts + [L]
        segs0 = [(k, b[k], b[k + 1]) for k in range(4)]          # (段号 0..3, 起, 止)
        st["used"] += 1
        reps = 1 if (a.val or hz < 12) else a.repeat_new
        jmax = 0 if a.val else int(round(a.jitter_s * hz))
        cf_n = int(round(a.cf_s * hz))
        for _ in range(reps):
            segs = [list(x) for x in segs0]
            for i in range(1, 4):
                sh = int(rng.integers(0, jmax + 1)) if jmax else 0
                sh = min(sh, max(0, segs[i - 1][2] - segs[i - 1][1] - a.min_frames))
                segs[i - 1][2] -= sh; segs[i][1] -= sh; st["jitter_frames"] += sh
            for i, (k, s0, s1) in enumerate(segs):
                if s1 - s0 < a.min_frames:
                    st["skipped_short"] += 1; continue
                act = truncate_at_end(d["action"][s0:s1], s0, s1, hz)
                add_episode(d, s0, s1, tasks[k], act, "seg", [name, ep], k + 1)
                st["seg"] += 1; st["seg_frames"] += s1 - s0
                if i > 0:   # 人工切点之后的保持样本:提示词 = 上一段
                    b0 = segs0[i][1]
                    grip_last = d["action"][b0 - 1].reshape(H, D)[0, GRIP]
                    for t in range(b0, min(b0 + cf_n, segs0[i][2])):
                        hold = np.empty(D, np.float32)
                        hold[POSE] = d["state"][t, POSE]; hold[GRIP] = grip_last
                        add_episode(d, t, t + 1, tasks[k - 1], np.tile(hold, H)[None], "cf_hold", [name, ep], k)
                        st["cf"] += 1
    print(f"{name}: 用 {st['used']} 条(剔除 {st['dropped']}、未确认 {st['unconfirmed']}、切点不全 {st['bad_cuts']},改左右 {st['side_fixed']})"
          f" → 分段 episode {st['seg']} 个,{st['seg_frames']} 帧;保持样本 {st['cf']} 帧;切点前移共 {st['jitter_frames']} 帧;过短段 {st['skipped_short']}",
          flush=True)
flush()
pd.DataFrame(ep_rows).to_parquet(dst / "meta/episodes/chunk-000/file-000.parquet", index=False)
pd.DataFrame({"task_index": list(range(len(PROMPTS)))}, index=pd.Index(PROMPTS, name="task")).to_parquet(dst / "meta/tasks.parquet")
info = json.load(open(Path(a.src[0]) / "meta/info.json"))
info.update(total_episodes=st_all["ep"], total_frames=st_all["gidx"], total_tasks=len(PROMPTS), splits={"train": "0:%d" % st_all["ep"]})
json.dump(info, open(dst / "meta/info.json", "w"), indent=4)
shutil.copy(Path(a.src[0]) / "meta/stats.json", dst / "meta/stats.json")
rep0 = json.load(open(Path(a.src[0]) / "conversion_report.json"))
rep0 = {k: v for k, v in rep0.items() if k != "episodes"}
json.dump({"args": vars(a), "prompts": PROMPTS, "base_report": rep0, "episodes": report},
          open(dst / "build_report.json", "w"), ensure_ascii=False)
links = sorted({(c, str(p), "videos/%s/chunk-%03d/file-%03d.mp4" % (c, *v)) for (c, p), v in video_map.items()})
with open(dst / "video_links.tsv", "w") as f:   # 新视频路径 ← 原视频路径,用于在别的机器上重建硬链接
    for c, p, newp in links:
        f.write(f"{newp}\t{p}\n")
n_cf = sum(1 for r in report if r["kind"] == "cf_hold")
print(f"完成:{dst},episode {st_all['ep']} 个(其中保持样本 {n_cf}),共 {st_all['gidx']} 帧,数据文件 {st_all['file']} 个", flush=True)