EndeavourDD/zihiao_real_test

tacWAM wet-lab 策略 — 推理与真机部署

把 一帧实测机器人状态 变成 八个绝对位姿 + 八组手指目标，10 Hz。

任务：盖子放入容器（cap_to_tray）。硬件：xArm6 + BrainCo Revo2 右臂右手， 佩戴图鉴 EI-G012 触觉手套；静态桌面头相机 + 右腕 D405。

---

⚠️ 先读这一节

这两个 checkpoint 8 道门过 7 道，只差 hand_in_sensor_range（会预测出负的手指计数）。

轨迹本身是可用的：从第 1 拍起就优于「原地不动」基线，到第 8 拍（0.8 秒） 误差 31.7 mm 对基线 59.5 mm，方向余弦 +0.60～+0.84。详见「离线评测结果」一节。

手指必须夹取（ActionChunk.clipped_hand()），代码里已经在示例回路中调用。

请把这次真机测试当作有人在急停按钮旁的探索性测试，不是验收。 另外：

• 这里没有失败检测、力控兜底、碰撞检查或急停逻辑，全部由你方系统提供。
• deploy_example.py 里有一道 60 mm/拍 的位移上限保护，那是最低限度的护栏，不是安全系统。
• 采样从高斯噪声起步，同一个观测两次调用结果不同。要复现就固定种子。

---

1. 硬件要求与性能实测

单卡即可。实测环境：NVIDIA H200 (143 GB)，PyTorch bf16。

项目	实测
权重显存	7.6 GiB
运行峰值显存	10.2 GiB（≥16 GB 的卡都够）
模型加载	23–25 秒
首次 act()（kernel warmup）	1.2–4.0 秒 ← 务必预热

单次 act() 稳态耗时（median / p90）：

UniPC 步数	vanilla_rgb	v10_tactile	一次调用买到的执行时长
5	0.49 / 0.50 s	0.39 / 0.42 s	8 拍 = 0.80 s ✅
10	0.76 / 0.85 s	0.66 / 0.68 s	8 拍 = 0.80 s ✅ 建议值
20	1.43 / 1.57 s	1.17 / 1.18 s	❌ 超出 0.80 s
30	1.88 / 1.92 s	1.65 / 1.70 s	❌

由此决定的运行方式（重要）

训练时记的建议是「预测 8 拍、执行前 4 拍、每 0.4 秒重规划」。 这个节奏在实机上跑不动：0.4 秒只够 8 拍里的 4 拍，而最快的采样也要 0.39 秒，没有余量。

改为：执行全部 8 拍（0.8 秒），每 0.8 秒重规划一次，UniPC 用 10 步。 稳态 0.66–0.76 秒 < 0.80 秒，留出约 5–15% 余量。

降到 5 步并不会明显变差（下表），如果你的卡比 H200 慢，先降步数而不是缩短时域。

UniPC 步数	t8 误差 p50	首次胜过原地不动	通过门数
5	51.0 mm	t5	7/8
10	41.8 mm	t4	7/8
20	49.0 mm	t6	7/8

（vanilla@4000，seed 20260904，20 次 replan。三者差异很可能在种子噪声之内。）

---

2. 包内容与安装

HuggingFace 上有两个 zip，解压到同一个目录即可，不需要再下载任何东西：

tacwam_wetlab_infer.zip    12.6 GB   代码 + 两个 checkpoint bundle + 配置
base_models.zip            11.3 GB   Cosmos3-Edge 基座 + Wan2.2 VAE 缓存

unzip tacwam_wetlab_infer.zip
unzip base_models.zip

解压后：

tacwam_wetlab_infer/
├── new_infer/                  推理代码
│   └── checkpoints/
│       ├── vanilla_rgb_step4000/    6.3 GB  ← 建议先用这个
│       └── v10_tactile_step4000/    6.3 GB
├── tacwam/                     被 import 的 Python 包
├── docs/reference/tujian_glove_geometry/          触觉手套几何（触觉必需）
└── docs/v10/manifests/normalization_v7_pad10_post0802.json   触觉 pad 归一化
base_models/
├── Cosmos3-Edge/               8.6 GB  基座模型
└── hf_cache/                   2.7 GB  Wan2.2 VAE

为什么 checkpoint bundle 之外还需要基座

bundle 里是训练后的全部 3.370 B 权重（已逐张量核验与训练产出完全一致）， 但有四样东西不在里面，运行时都需要：

组件	来自	为什么不在 bundle 里
Wan2.2 VAE 2.7 GB	hf_cache/	视频编码器。框架用 object.__setattr__ 挂上去，不是 nn.Module 子模块，所以进不了 state_dict。每次 act() 都要用它把 RGB 编成 latent
网络架构与配置	Cosmos3-Edge/	from_pretrained_dcp(snapshot) 要读 snapshot 才能把网络搭出来，搭好之后才用 bundle 覆盖权重
scheduler 配置 8 KB	Cosmos3-Edge/scheduler/	UniPC 的采样参数
text tokenizer 17 MB	Cosmos3-Edge/text_tokenizer/	把中文任务名 盖子放入容器 编成 prompt token

实测：哪些能删，哪些不能

逐块拿掉再跑加载 + 采样，结果如下。除了 vae/ 那 1.4 GB，其余都删不得。

基座变体	大小	能否加载并采样
完整	8.6 GB	✅
去掉 vae/	7.3 GB	✅ 这 1.4 GB 确实没用上（框架用的是 Wan2.2 那个 VAE）
去掉 vision_encoder/	7.7 GB	❌
去掉 transformer/ 权重	2.3 GB	❌
只留配置 + tokenizer	33 MB	❌
完整基座，但没有 Wan2.2 VAE 缓存	—	❌

transformer/ 那 6.3 GB 的权重会被 bundle 完全覆盖，看起来冗余， 但 from_pretrained_dcp 只能通过读它把网络构造出来——建好之后才谈得上覆盖权重。 所以它是脚手架，不是可选项。

包里为省事保留了 vae/，删掉也能跑。

必须设置的两个路径

① 基座路径。 run_config.json 里记的 snapshot 是我们训练集群的绝对路径， 在别的机器上必须覆盖，否则加载直接失败：

WetlabPolicy.from_run(bundle, base_model="/path/to/base_models/Cosmos3-Edge")

--base-model /path/to/base_models/Cosmos3-Edge

② HF 缓存。 否则框架会 shell out 去联网下载 Wan2.2 VAE：

export HF_HOME=/path/to/base_models/hf_cache

设好这两个之后不需要外网。日志里如果出现 Downloading checkpoint Wan2.2/vae，说明 HF_HOME 没设对。

Python 环境

依赖 cosmos_framework（NVIDIA 开源，含 pyproject.toml）及其固定版本的 TransformerEngine / diffusers / torch。我们的 venv 里烧了绝对路径，搬不动， 请在你方机器上装：

git clone <cosmos-framework>       # 与训练时同一版本
cd cosmos-framework && uv sync

装完注意一点：TransformerEngine 2.12 会去 $CUDA_HOME 找 cudart， 而 pin 的 wheel 装的是 nvidia/cuda_runtime 而不是 nvidia/cuda_cudart。 run.sh 里的做法是把 CUDA_HOME 指向 venv 内的 site-packages/nvidia 并把各子包的 lib 加进 LD_LIBRARY_PATH，换机器时保持这个设置。

---

3. 快速验证（新机器上按顺序跑）

run.sh 把这个集群的五项隐式依赖都包好了（自带 uv / git-lfs、CUDA_HOME、 LD_LIBRARY_PATH、COSMOS_FRAMEWORK_ROOT、PYTHONPATH）。换机器时改里面的路径即可。 所有命令从仓库根目录执行。

第 1 步 — 契约自检（不需要 GPU，几十秒）

./new_infer/run.sh selftest.py --run-dir new_infer/checkpoints/vanilla_rgb_step4000

期望输出：

windows checked          26
row 0 max |live - train| 0.000e+00      ← 必须是 0
decoded pose max |err|   9.313e-06  (mm for translation)
decoded hand max |err|   6.104e-05  (raw counts)
state/action scale ratio 5.9x
SELFTEST: PASS

它不加载模型，只检查编解码那条缝。历史上真正出过错的就是这里， 所以每次改动之后、每次部署之前都跑一遍。（这一步需要带上原始数据集才能跑； 如果你方没有数据集，跳到第 2 步。）

第 2 步 — 空跑整个部署循环（需要 GPU）

./new_infer/run.sh deploy_example.py \
  --run-dir new_infer/checkpoints/vanilla_rgb_step4000 \
  --base-model /your/path/to/Cosmos3-Edge \
  --dry-run --ticks 16 --seed 1

它用一个桩机械臂跑完整个循环并打印每次会下发的指令：

[deploy] variant=vanilla_rgb task=盖子放入容器
[deploy] warm-up 4.00s (discarded)
[deploy] chunk 0.60s -> 8 ticks  xyz=[383.1  69.3 189.3]  hand=[135. 180. 337. 142. 438. 332.]
[deploy] chunk 0.62s -> 8 ticks  xyz=[399.5  40.9 185.8]  hand=[141. 186. 243. 248. 462. 536.]
[deploy] dry run issued 16 setpoints

看到 chunk 行的耗时小于 0.80 s，说明这张卡撑得住建议的运行节奏。

第 3 步 — 接上真机

实现 deploy_example.py 里的 RobotInterface 六个方法，去掉 --dry-run。

---

4. 输出格式 —— 怎么用它控制机械臂

policy.act(observation) 返回一个 ActionChunk。这是全文最该看清楚的一节。

4.1 它给你什么

chunk = policy.act(observation, n_steps=10)

chunk.poses_abs      # [8, 4, 4] float64  八个绝对位姿（齐次变换矩阵）
chunk.hand_targets   # [8, 6]    float64  八组绝对手指目标
chunk.positions      # [8, 3]    float64  = poses_abs[:, :3, 3] 的快捷方式
chunk.anchor_pose    # [4, 4]    float64  这批增量复合到的那个实测位姿

八行分别对应观测时刻之后的 0.1、0.2、…、0.8 秒，即 10 Hz。 chunk.poses_abs[k] 是 t₀ + (k+1) × 0.1 秒的设定点，t₀ 是你读取观测的那一刻。 没有 t₀ 本身的设定点——那是你喂进去的 state，不是要下发的东西。

chunk.tick_times(observation.timestamp_ns)   # -> 每一拍对应的绝对纳秒时间

4.2 位姿的格式

每个 poses_abs[k] 是标准 4×4 齐次变换：

┌                    ┐
│  R(3×3)   t(3×1)   │     R = 旋转矩阵
│  0  0  0     1     │     t = 平移，单位【毫米】
└                    ┘

poses_abs[k][:3, :3]  →  旋转矩阵
poses_abs[k][:3,  3]  →  x, y, z（mm）

坐标系 = 你传进来的 tcp_pos / tcp_quat_wxyz 所在的坐标系。 模型本身不知道任何坐标系，它只输出相对运动；这里的绝对值是那些相对运动 复合到你自己的实测位姿上得到的。所以你喂的是机器人基坐标系下的 TCP， 拿到的就是同一坐标系下的 TCP 目标，可以直接下发。

4.3 转成你的 SDK 要的格式

# ✅ 四元数（wxyz）—— 推荐
positions_mm, quats_wxyz = chunk.as_pos_quat()      # [8,3], [8,4]

# ✅ 或者直接用矩阵
R = chunk.poses_abs[:, :3, :3]

经过框架的 convert_rotation，与训练侧同一个 seam，往返误差 ~1e−7。

⛔ 这个任务不能用欧拉角，也不能用轴角

欧拉角：万向锁。 实测这批数据（预测和真值都一样）： **100% 的帧 |pitch| > 89.5°**，正好落在 euler_xyz 的万向锁上。 在那里 roll 和 yaw 不再各自确定，于是：

	实际姿态变化/拍	欧拉 roll 跳变	欧拉 yaw 跳变	四元数分量跳变
预测	中位 0.033°	中位 7.2° / max 359.0°	中位 7.5° / max 358.7°	中位 0.0002
真值	中位 0.033°	中位 8.4° / max 338.3°	中位 9.1° / max 357.9°	中位 0.0002

姿态每拍只动 0.03°，欧拉角却能跳 359°。角度本身没错，但任何控制器 在两个相差 359° 的 roll 之间插值——10 Hz 非阻塞下发时一定会插值—— 手腕就会乱转一圈。

所以 as_pos_euler_deg() 默认直接报错，除非你显式传 allow_gimbal_lock=True 表示你的控制器逐点绝对执行、不做欧拉插值。

轴角：更糟。 姿态同时落在 ±180° 奇点壳上 （实测 tcp_quat 均值 [3e−5, 0.70709, 4e−5, 0.70711]，w≈0）， sin θ → 0 导致转换发散：实测 17,803 帧里 |aa| 最大 1,313,357°， 相邻帧跳变中位 58.9°。这也是整个契约用 rot6d 而不用轴角的原因。

如果你的机械臂 SDK 只接受欧拉角或轴角（xArm 的 set_position 就是欧拉角）， 请用 arm.set_servo_cartesian() 之类接受矩阵/四元数的接口， 或者在你侧做连续化（unwrap）后再下发——不要直接把这八个欧拉角丢进去。

4.4 手指的格式

chunk.hand_targets   # [8, 6]，原始传感器计数

六个通道全是绝对目标位置，不是增量，和位姿那 9 维不一样。 合法范围 0…997，顺序与 obs/robot/right/hand_pos 一致（采数据时的手指编号）。

模型可能输出范围外的值（我们见过 −145 到 677）。下发前必须夹取：

chunk = chunk.clipped_hand(0.0, 997.0)

夹取故意不放进解码器——放进去的话 ship gate 就看不见模型在要求它没见过的值了。 所以这一步要你在执行器侧显式调用。

4.5 一个完整的下发例子

import numpy as np, time

t0 = time.time_ns()
observation = read_observation(robot, normalization)
chunk = policy.act(observation, n_steps=10)

# ① 夹手指  ② 取要执行的拍数  ③ 转成 SDK 格式
chunk = chunk.clipped_hand(0.0, 997.0).executed(8)
positions_mm, quats_wxyz = chunk.as_pos_quat()

for k in range(len(positions_mm)):
    x, y, z = positions_mm[k]                # mm
    qw, qx, qy, qz = quats_wxyz[k]           # 单位四元数
    fingers = chunk.hand_targets[k]          # [6] 计数 0..997

    arm.servo_to_pose(x, y, z, qw, qx, qy, qz)   # 你的 SDK，接受四元数或矩阵
    hand.set_positions(fingers)

    time.sleep(0.1)                          # 10 Hz，不可调

真实数值长这样（dry-run 实测，vanilla@4000）：

起点(实测)  xyz = [361.0,  78.0, 212.0]
第 8 拍     xyz = [383.1,  69.3, 189.3]     0.8 秒走了约 32 mm
            hand = [135, 180, 337, 142, 438, 332]

4.6 单位速查

量	单位	常见错误
位置（输入和输出）	毫米 mm	传成米 → 相差 1000 倍，不报错
四元数	wxyz	传成 xyzw → 姿态完全错，不报错（但 validate() 会查范数）
手指	原始计数 0…997	归一化成 0–1 → 不报错
时钟	10 Hz，固定	模型的时间基准写死在 mRoPE 里，改不了

前三个错误全部不会抛异常，只会让机械臂做出看起来合理但错误的动作。 selftest.py 检查的就是这一类问题。

---

5. 「每 0.4 秒重规划」是什么意思

5.1 基本概念

模型一次预测 8 拍 = 0.8 秒的未来。但你不会把这 0.8 秒全部执行完再去看下一眼。

「每 T 秒重规划」= 执行前 T×10 拍，把剩下的丢掉， 用新的实测观测重新预测一整批。这就是滚动时域（receding horizon / MPC）的做法。

t=0.0  观测 → 预测 8 拍 [■■■■□□□□]  执行前 4 拍，后 4 拍丢弃
t=0.4  观测 → 预测 8 拍 [■■■■□□□□]  执行前 4 拍，后 4 拍丢弃
t=0.8  观测 → 预测 8 拍 ...
       ■ = 实际下发   □ = 算了但丢掉

5.2 为什么要丢掉后一半

因为增量是乘法复合的。 契约里行 1..8 是 backward_framewise 相对位姿， 第 k 拍的绝对位姿是 T_k = T_anchor · ΔT_1 · ΔT_2 · … · ΔT_k。 每一个 ΔT 的误差都会乘进后面所有拍里，所以越靠后越不准—— 实测就是这样：t1 误差 8.1 mm，t8 误差 43.4 mm。

重规划把锚点重置回当前的实测位姿，误差不再累积。 这也是为什么 act() 必须每次传入新鲜的实测量， 而绝对不能把上一次的预测当作下一次的锚点。

5.3 我们把它改成了 0.8 秒

训练时记的建议是 0.4 秒（执行 4 拍）。实机上我们改成 0.8 秒（执行全部 8 拍），两个原因：

① 算不过来。 0.4 秒的预算里必须算完下一批，而单次采样最快 0.39 秒（UniPC 5 步）， 建议的 10 步要 0.66–0.76 秒。0.8 秒的预算才装得下，还剩约 25% 余量。

② 长时域误差增长比线性慢。 离线实测（median 误差，mm）：

              t1     t2     t3     t4     t5     t6     t7     t8
原地不动      6.7   14.1   22.2   29.5   36.8   45.1   53.0   59.5
vanilla@4000  6.2   11.8   14.9   19.2   23.4   27.4   30.0   31.7

真值在 0.8 秒里走了 59.5 mm，而预测误差只累积到 31.7 mm， 说明第 5–8 拍仍然携带有用信息，不是纯外推噪声。丢掉它们没有收益。

5.4 你可以怎么调

EXECUTED_TICKS = 8    # deploy_example.py 里的常量
UNIPC_STEPS    = 10

约束是：采样耗时 < 执行拍数 × 0.1 秒。deploy_example.py 会在违反时打印警告。

执行拍数	重规划周期	需要的采样速度	建议
8	0.8 s	< 0.80 s	✅ 当前配置（10 步，0.66–0.76 s）
4	0.4 s	< 0.40 s	⚠️ 只有 5 步勉强够，且用的是模型最弱段
2	0.2 s	< 0.20 s	❌ 达不到

拍数不能超过 8——模型只预测 8 拍。 10 Hz 的时钟也不能改，它写死在 mRoPE 的时间编码里。

---

6. 完整示例代码

deploy_example.py 是一个可直接运行的完整部署循环，不是片段。 你只需要填一个类，其余不用动。

class RobotInterface:
    """这六个方法全部返回【实测值】，不是你下发的指令值。

    实测 = 从编码器和传感器读回来的。模型就是用实测流训练的，
    因为指令流会和现实脱节；推理时喂指令值是它无法察觉的分布偏移。
    """

    def head_image(self) -> np.ndarray:
        """静态桌面头相机，[H, W, 3] uint8 RGB。"""

    def wrist_image(self) -> np.ndarray:
        """右腕相机 D405，[H, W, 3] uint8 RGB。"""

    def tcp_pose(self) -> tuple[np.ndarray, np.ndarray]:
        """右臂 TCP 实测量：(position_mm[3], quaternion_wxyz[4])。
        毫米不是米。wxyz 不是 xyzw。两个搞错都不会报错。"""

    def hand_position(self) -> np.ndarray:
        """六指实测位置，原始计数 0..997。"""

    def tactile_pads(self) -> dict[str, np.ndarray] | None:
        """手套原始 pad：{"tactile_<pad_id>": 法向力数组}。
        vanilla_rgb 变体返回 None。"""

    def servo_to(self, pose: np.ndarray, hand: np.ndarray) -> None:
        """下发一个 10 Hz 设定点：4x4 位姿（平移 mm）+ 6 个计数。"""

主循环（已在 deploy_example.py 里实现好）：

policy = WetlabPolicy.from_run(BUNDLE, base_model=COSMOS_SNAPSHOT)

# 预热：首次 act() 要付 CUDA kernel 自动调优的代价（3.5 s vs 稳态 0.61 s），
# 真机上这会让第一个 chunk 直接超时。
policy.act(read_observation(robot, normalization), n_steps=10)

while running:
    observation = read_observation(robot, normalization)   # 一个同步瞬间
    chunk = policy.act(observation, n_steps=10)            # 约 0.66–0.76 s

    chunk = chunk.clipped_hand(0.0, 997.0).executed(8)     # 夹取只在执行器侧做
    poses = guard(chunk, observation.tcp_pos)              # 60 mm/拍 上限

    for pose, hand in zip(poses, chunk.hand_targets[:len(poses)]):
        robot.servo_to(pose, hand)                         # 10 Hz
        time.sleep(0.1)

guard() 会截断任何单拍位移超过 60 mm 的 chunk。演示数据每拍平均走 9.4 mm、 p95 是 19.6 mm，所以 60 mm 明显是异常。这是最低限度的护栏，不是安全系统—— 失败检测、力控兜底、碰撞检查、急停都要你方提供。

最小调用

from new_infer import Observation, WetlabPolicy

policy = WetlabPolicy.from_run(
    "new_infer/checkpoints/vanilla_rgb_step4000",
    base_model="/your/path/to/Cosmos3-Edge",
)

chunk = policy.act(Observation(
    rgb_head        = head_rgb,          # [H,W,3] uint8，内部会 resize 到 256
    rgb_wrist_right = wrist_rgb,
    tcp_pos         = np.array([361.0, 78.0, 212.0]),      # mm，实测
    tcp_quat_wxyz   = np.array([0.0, 0.7071, 0.0, 0.7071]),# wxyz，实测
    hand_pos        = np.full(6, 300.0),                   # 0..997，实测
    timestamp_ns    = time.time_ns(),
    tactile_maps    = None,   # vanilla_rgb 不要传触觉
    taxel_valid     = None,
), n_steps=10)

带触觉的变体

from new_infer import tactile_tick_from_raw_pads
from tacwam.cosmos_tactile.pad_data import PadNormalization

pads_norm = PadNormalization.from_json("docs/v10/manifests/normalization_v7_pad10_post0802.json")
maps, valid = tactile_tick_from_raw_pads(read_glove_pads(), pads_norm)   # 已含左右重映射

read_glove_pads() 返回 {"tactile_<pad_id>": 法向力数组}， 就是 *_hand_data.npz 里单个时刻的那些数组。 不要自己再做左右搬运，tactile_tick_from_raw_pads 已经做了（原因见第 8.2 节）。

---

7. Observation 每个字段的含义

字段	形状 / 类型	单位	必须注意
rgb_head	[H,W,3] uint8	RGB	静态桌面头相机，不是第一视角；内部 resize 到 256×256
rgb_wrist_right	[H,W,3] uint8	RGB	右腕 D405
tcp_pos	[3] float	mm	实测量，不是目标位
tcp_quat_wxyz	[4] float	—	wxyz 顺序；非单位四元数会被拒绝
hand_pos	[6] float	原始计数 0..997	实测量；不要归一化
timestamp_ns	int	ns	只用于触觉的 mRoPE 时间戳
tactile_maps	[30,1,H,W]	已归一化	用 tactile_tick_from_raw_pads 生成
taxel_valid	[30,H,W] bool	—	左半 15 槽必须全 False

Observation.validate() 会挡下四类静默错误：非有限值、四元数不是单位 （多半是把 xyzw 当成了 wxyz）、左手槽位还带着 valid、以及 vanilla 变体收到了触觉。

代码看不出、必须你保证的两件事：

1. 六个读数来自同一时刻，且都是实测而非指令值；
2. 相机外参、手套贴装位置、手指编号顺序跟采数据时一致。

---

8. 契约细节（想改代码再看）

模型每次看到 9 行 × 15 维：

行 0     绝对状态，条件行，不是生成目标
行 1..8  相对增量，生成目标（10 Hz，共 0.8 秒）

通道	含义	单位	行 0	行 1..8
[0:3]	TCP 位置	mm	绝对	backward_framewise 增量
[3:9]	rot6d	—	绝对姿态	增量姿态
[9:15]	六指位置	计数 0..997	绝对	仍然绝对

其它必须逐字对齐的常量：domain id = 23；rot6d = 旋转矩阵的前两列； prompt = TextConditioner(structured_action_prompt=False, use_system_prompt=False).encode_name("盖子放入容器")； 两套 quantile_rot_scale_floor 归一化（行 0 用 state 那套，行 1..8 用 action 那套，不做 forward clamp）。

数据来源全部是实测流 obs/robot/right/*。这一点反复确认过： AgiBot 用 observation.states.joint.position 做 FK，UMI 用 SLAM 实测轨迹， 没有人拿遥操指令当 label。datacard 推荐的 command 契约我们没有采纳。

8.1 训练时的 instruction 形式

模型是文本条件的，prompt 在推理时必须和训练时逐字一致—— 它不只是语义提示，还决定了后面所有模态的 mRoPE 时间偏移。 WetlabPolicy 已经从 run_config.json 的 task_name 自动重建，你不需要也不应该自己传 prompt。 这里写出来只是为了让你知道模型见过的是什么。

构造方式：

TextConditioner(
    snapshot,
    fps=10.0,
    resolution=256,
    num_frames=9,
    structured_action_prompt=False,   # 不用 Cosmos 的 action JSON formatter
    use_system_prompt=False,          # 不加 system prompt
).encode_name("盖子放入容器")

encode_name 先查中英翻译表，查不到就回落中文原文。 task_translations.json 里的 116 条与本任务名零重合，所以实际用的就是中文原文。 然后套上 Cosmos 的时长/分辨率模板，拼成：

盖子放入容器. The video is 0.9 seconds long and is of 10 FPS. This video is of 256x256 resolution.

再经 chat template 包装，最终喂给模型的 59 个 token 解码回来是：

\n<|im_start|>system\n<|im_end|>\n<|im_start|>user\n盖子放入容器. The video is 0.9 seconds long and is of 10 FPS. This video is of 256x256 resolution.<|im_end|>\n<|im_start|>assistant\n<think>\n<|im_end|><|vision_start|>

几个要点：

项	值	说明
语言	中文任务名 + 英文模板	不是纯英文。V10 mid-training 的 21,043 条也全是这个形式，post-train 与之对齐
system prompt	无	use_system_prompt=False，所以 <|im_start|>system 后面是空的
action JSON formatter	不用	structured_action_prompt=False。bottle-cap 那版用了，会在前面塞一段 action schema，并移动后面所有模态的 mRoPE 偏移
时长	0.9 seconds	= num_frames 9 / fps 10.0，即 1 个当前帧 + 8 个未来帧
分辨率	256x256	与 cfg.resolution 一致
结尾	<|vision_start|>	start-of-generation 标记，token id 20
每个 run 固定	是	一个 run 只训一个任务，prompt 不随窗口变化

换任务需要重新 post-train，不是换个 prompt 字符串就行—— 这批数据只有 cap_to_tray 一个任务，模型没见过别的指令。

这个包的设计原则

推理不重新实现契约，而是 import 训练用的那一份。 contract.py 里几乎没有计算，只有 re-export 和断言。 历史上的一串「坑」不是一串独立 bug，是同一个结构问题： 契约用约定表达而非用代码表达，训练侧和推理侧各写一份就会漂开。

历史问题	处置
两套 normalizer 可互换（state/action pos_x scale 差 5.9×，用错不报错）	启动断言；编解码函数签名各只接受一套；selftest 校验比值 ≥ 4×
锚点用成上一次预测（乘法复合，误差累积且不可见）	encode_conditioning_row() 连锚点一起返回，拿不到「无锚点的 chunk」
手指通道被误当作增量复合	解码只对 [0:9] 复合；selftest 逐窗口比对到 6e−5 计数
rot6d 前两行 vs 前两列（实测 R 非对称，max|R−Rᵀ|=0.218）	只留 matrix_to_rot6d() 一个 seam，转发框架 convert_rotation
触觉左右映射在推理侧重写	remap_single_glove() 离线在线共用
checkpoint 是 DCP 16 分片，旧脚本读 safetensors	两种格式都支持；bundle 走 safetensors
旧 rollout 脚本从未 model.to(device)	补上，并 requires_grad_(False)
prompt 开关不一致（旧脚本 structured_action_prompt=True，会移动后续所有 mRoPE 偏移）	从 run_config.json 读 task_name，用训练时的开关重建

8.2 为什么触觉要做左右重映射

这套装置只有一只手套，而且它的 880 个触觉点是从名为 left 的文件里出来的 （right_hand_data.npz 是死的，53 条 episode 里 max 0.001、std 0.0000）。 训练时把活的 pads 搬进右手槽位，左半 mask 成 invalid—— 不是填 0，因为 0 是合法的「没接触」读数，会教会模型左手一直贴在一个平面上。

tactile_tick_from_raw_pads() 和 remap_single_glove() 已经做好这件事， 不要在外面再做一次。

---

9. 离线评测结果

offline_rollout.py 按真机的方式回放：每次只喂一个实测瞬间，预测 8 拍， 0.8 秒后换下一个真实观测。未来的 RGB / 触觉 / 动作目标从不暴露给采样器。 观测是从 h5 的实测流经 Observation 组装的，所以它同时也在测在线编码器。

ship_gate.py 回答 val loss 回答不了的问题。门槛全部挂在演示数据自己的尺度上 （10 Hz 模型时钟、5902 个训练窗口实测）：每拍 |Δxyz| mean 9.38 / p50 8.38 / p95 19.62 mm， 方向反转率 **5.1%**。

逐 tick 误差（median，mm）

UniPC 10 步，seed 20260904，20 次 replan × 5 条验证 episode。

              t1     t2     t3     t4     t5     t6     t7     t8
原地不动      6.7   14.1   22.2   29.5   36.8   45.1   53.0   59.5
vanilla@4000  6.2   11.8   14.9   19.2   23.4   27.4   30.0   31.7   ← t8 领先 47%
tactile@4000  5.8   11.6   17.0   22.4   28.9   36.1   39.0   41.8

方向余弦（median）：

vanilla@4000  +0.66  +0.62  +0.60  +0.71  +0.70  +0.83  +0.84  +0.77
tactile@4000  +0.67  +0.72  +0.78  +0.66  +0.68  +0.68  +0.74  +0.70

两个 checkpoint 从第 1 拍起就优于「原地不动」。 最小二乘步长尺度 0.46（vanilla）/ 0.53（tactile）——步子仍偏保守， 但方向跟得上，所以误差增长明显慢于基线。

八道门

gate	判据	vanilla@4000	tactile@4000
tick1_within_one_demo_step	第 1 拍误差 p50 ≤ 19.62 mm	ok	ok
executed_within_horizon_span	执行段误差 p95 ≤ 19.62×4 mm	ok	ok
beats_stall_on_executed	执行段优于原地不动	ok	ok
beats_stall_at_horizon	t8 优于原地不动	ok	ok
direction_tracks_truth	方向余弦中位 ≥ 0.5	ok	ok
step_size_in_band	步长是演示的 0.5×–2×	ok	ok
no_direction_chatter	反转率 ≤ max(5%, 2×基线)	ok	ok
hand_in_sensor_range	手指落在 0..997	FAIL −69.5…351.8	FAIL −45.8…308.6

唯一未过的是手指范围：模型会预测出负的计数。 真机上用 ActionChunk.clipped_hand(0.0, 997.0) 夹取即可，示例回路里已经调用。 夹取故意不放进解码器——放进去 gate 就看不见模型在要求它没见过的值了。

⚠️ 关于这些数字的可靠性

采样从高斯噪声起步，所以单次 rollout 是一次抽样而不是测量。 --seed 默认 20260904，上表是单种子结果。跨 checkpoint 的比较需要多种子重跑才能定论。

另外一条实测教训：这些数字曾经全部是错的。推理侧的 row-0 rot6d 计算有过一个 广播 bug（六个槽位被填成同一个标量），当时 gate 显示两个 checkpoint 都不如 「原地不动」。selftest.py 那时报 row 0 max |live - train| 0.000e+00—— 因为它拿新代码比新代码，两边一起错就会互相同意。 现在 selftest 增加了一条对照训练产物的检查：从数据重新拟合归一化统计量， 必须与 run_config.json 里的逐位相同。那份统计量是训练时写的， 推理侧的任何漂移都会被它抓住。

---

10. 文件清单

文件	作用
deploy_example.py	完整可运行的部署循环，含 --dry-run
contract.py	Observation / ActionChunk / 编解码 re-export / 触觉重映射 / 断言
policy.py	WetlabPolicy.from_run() + UniPC 联合采样
selftest.py	CPU 契约自检
benchmark.py	延迟与显存实测
offline_rollout.py	保留时域回放
ship_gate.py	演示基线 + 八道门
export_checkpoint.py	DCP → 推理 bundle
verify_bundle.py	逐张量核验 bundle 与原 checkpoint 一致
run.sh	环境包装器
run_offline_rollout.sbatch	selftest → rollout → gate 一条龙
checkpoints/*/	两个 bundle

常用命令

# 契约自检（无 GPU）
./new_infer/run.sh selftest.py --run-dir new_infer/checkpoints/vanilla_rgb_step4000

# 空跑部署循环
./new_infer/run.sh deploy_example.py --run-dir new_infer/checkpoints/vanilla_rgb_step4000 \
    --dry-run --ticks 16 --seed 1

# 延迟 / 显存
./new_infer/run.sh benchmark.py --run-dir new_infer/checkpoints/vanilla_rgb_step4000

# 离线 rollout + gate（本集群）
sbatch --export=ALL,WETLAB_RUN=new_infer/checkpoints/vanilla_rgb_step4000,N_STEPS=10 \
       new_infer/run_offline_rollout.sbatch

# 重新导出并核验 bundle
./new_infer/run.sh export_checkpoint.py --run-dir <训练 run> --step 4000 --drop-vae \
    --output new_infer/checkpoints/<名字>
./new_infer/run.sh verify_bundle.py --bundle new_infer/checkpoints/<名字> \
    --run-dir <训练 run> --step 4000        # 必须打印 VERIFY: IDENTICAL

---

11. 故障排查

现象	原因
加载时报路径不存在	run_config.json 的 snapshot 是训练集群绝对路径，用 --base-model 指向 base_models/Cosmos3-Edge
卡在 Downloading checkpoint Wan2.2/vae	HF_HOME 没指向 base_models/hf_cache
RuntimeError: cudart shared object not found	TE 2.12 找不到 cudart，把 CUDA_HOME 指向 venv 内的 site-packages/nvidia
FileNotFoundError: 'uvx'	框架运行时要调 uvx，把带 uv 的目录加进 PATH（run.sh 已做）
No CUDA GPUs are available	框架构造模型硬性要求 CUDA，导出 / 核验 / 推理都要卡；只有 selftest.py 不用
四元数被拒	传成了 xyzw，或者没归一化
左手槽位 valid	自己又做了一次左右搬运；tactile_tick_from_raw_pads 已经做过了
每次结果都不一样	正常，采样是随机的；固定 torch.manual_seed()
chunk 耗时警告	采样比它买到的执行时长还久；降 --n-steps 或加 --executed-ticks

---

12. 能力边界

• 单任务。 prompt 每个 run 固定为 盖子放入容器。换任务要重新 post-train。
• 53 条 episode（48 训 5 验）。 这个规模下 gate 只能证明「没坏」，证明不了泛化。
• 触觉这一版没有帮上忙。 训练共享项 action_flow 0.1961（tactile）对 0.1482（vanilla）， 触觉更差 32.3%；离线 rollout 也是 vanilla 更准。 触觉损失只占总损失的 0.8%，所以「触觉抢容量」这个解释被实测否掉了； 更可能是单手套 + 30 个 pad 槽位里只有一半是活的，信噪比不够。 建议真机先用 vanilla_rgb_step4000。
• 不要用 val loss 选 checkpoint。 两条 arm 的 val 在 step 2750 左右就平了， 但轨迹质量在那之后还在改善；val 选出的 3500/3000 在 t3 以后全面差于 4000。
• 开环。 无失败检测、无力控兜底、无急停。
• 离线 rollout 不等于真机。 手臂始终没有真的偏离演示轨迹， 所以它测不到误差累积后的恢复能力——而这恰恰是真机上最先出问题的地方。