| |
| |
| """天机 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 |
| POSE = [i for a in (0, 10) for i in range(a, a + 9)] |
| 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)] |
| 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) |
|
|
