yam-pick-duster-ee — end-effector space (bspline / tidybot2 format)

50 teleoperated demonstrations of a single I2RT YAM arm picking up a duster, recorded in VR. End-effector pose state and action, two camera views, in the on-disk layout used by bspline-policy's real_env (originally tidybot2).

These are the same 50 takes as Dimios45/yam-pick-duster, which holds the joint-space version — same episodes, same wall-clock spans, different action space and format. Both were written from one control loop, so episode N is the same demonstration in each.

At a glance

Episodes	50
Frames	11,215 @ 10 Hz (18.7 min)
Episode length	158–314 frames (15.8–31.4 s), median 218
Robot	I2RT YAM, 6-DoF + linear_4310 gripper, right arm only
Cameras	top_image (fixed overhead), wrist_image — both 640×480 RGB, uncropped
Task	pick up the duster

End-effector path per episode is 1.34–2.14 m (median 1.64 m); ~88% of frames contain motion. No idle or dead takes.

Layout

<YYYYmmddTHHMMSS%f>/
    top_image.mp4      H.264, one frame per step, 10 fps
    wrist_image.mp4
    data.pkl           {'timestamps': [...], 'observations': [...], 'actions': [...]}

Image entries inside data.pkl are None — the frames live in the mp4s and are re-attached on load, which is what the reference EpisodeReader does.

Per step:

observation  arm_pos      float64 (3,)   TCP position, arm base frame
             arm_quat     float64 (4,)   xyzw, w >= 0
             gripper_pos  float64 (1,)   0 = open, 1 = closed
             top_image    uint8 (480, 640, 3) RGB
             wrist_image  uint8 (480, 640, 3) RGB
action       arm_pos, arm_quat, gripper_pos   (same shapes, no images)

observation is forward kinematics of the measured joints; action is forward kinematics of the commanded joints — i.e. what the teleoperator asked the arm to do on that tick.

Conventions

• Gripper: 0 = open, 1 = closed (the inverse of i2rt's native normalisation, converted at record time).
• Quaternion: xyzw, restricted to the w >= 0 hemisphere so q and -q never alternate between frames.
• TCP frame: the link_6 flange origin, re-axed by a fixed 90° rotation about z — the same point and axes yam_server.get_state() reports. This is not the fingertip; the grasp point sits ~13.5 cm further along the gripper's approach axis.

Kinematic caveat. These poses are computed from the MuJoCo model in vr-teleop-kit, which disagrees with bspline-policy's pyroki/URDF chain by up to ~9 mm at the same joint angles (verified in float64; it is a real model difference, not numerical noise, and it is not a fixed offset you can correct away). Do not mix these episodes with ones recorded through that stack's yam_server, and do not deploy a policy trained on this data through it without resolving the discrepancy first. Collected and deployed within one stack the data is self-consistent, which is all a policy needs — it never sees an IK solver.

Loading

Any episode reads with ~20 lines of pickle + OpenCV, or with the reference reader:

import sys; sys.path.insert(0, "<bspline-policy>/real_env/yam_teleop")
from episode_storage import EpisodeReader

r = EpisodeReader(Path("20260817T002459489956"))
r.observations[0]["arm_pos"]      # (3,)
r.observations[0]["wrist_image"]  # (480, 640, 3) uint8 RGB

reviewer.py, sort_demos_from_review.py and convert_to_robomimic_hdf5.py all consume this directory unchanged.

Training a B-spline diffusion policy

# from bspline-policy/real_env/yam_teleop
python convert_to_robomimic_hdf5.py --input-dir <this-dataset> --output-path yam_ee.hdf5

That yields obs/{arm_pos, arm_quat, gripper_pos, wrist_image, top_image} and actions (N, 7) = [pos(3), rotvec(3), gripper(1)]. The dataset class converts the rotvec to rotation_6d, so the trained action is 10-dim — the stack's single_yam_rot6d format. Matching shape_meta:

shape_meta: &shape_meta
  obs:
    wrist_image: {shape: [3, 84, 84], type: rgb}
    top_image:   {shape: [3, 84, 84], type: rgb}
    arm_pos:     {shape: [3]}
    arm_quat:    {shape: [4]}
    gripper_pos: {shape: [1]}
  action:
    shape: [10]

with rotation_rep: 'rotation_6d' and abs_action: True.

To apply a crop during conversion, use tools/to_robomimic.py --from bspline from vr-teleop-kit instead; it produces the same HDF5 and stamps the crop into the file's attributes.

Deploying

Unlike the joint-space version, a policy trained here emits Cartesian poses, so the deployment side needs inverse kinematics. vr-teleop-kit's EEFollower holds the latest target and steps a damped-least-squares IK toward it at 100–200 Hz. Three things it handles that are easy to get wrong:

• Posture bias. The IK's Tikhonov term leaves a steady-state offset against a fixed target — 3.4 mm at the teleop default, 0 at mu=0. Build the rollout solver with a low mu.
• Target frame. The policy emits flange-convention poses; the solver targets the fingertip site 13.47 cm away. Use target_frame="tcp".
• Reach clamp. Bound each target to a ball around the arm's current pose. Without it an out-of-workspace command stretches the arm to full extension, where it can pin joints 2/3 against their limits with the wrist at exactly ±π/2 — a genuine deadlock that does not recover.

Cropping

Frames are stored uncropped so the crop can be retuned without re-recording. The overhead camera's useful region is roughly x=42, y=28, w=598, h=414. The wrist camera sees the room above the table horizon (~y=110 at the home pose), but that crop is pose-dependent — the horizon moves as the arm pitches — so verify across your workspace.

Whatever crop is used for training must be applied identically at deployment.

Recording setup

Meta Quest controllers → WebXR → differential IK → joint commands, via vr-teleop-kit. The arm is commanded at 200 Hz; this dataset is sampled from that loop at 10 Hz. Episodes start from a consistent home pose (start poses agree to 0.30 mm across all 50).

Licence

Apache-2.0.