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

200 teleoperated demonstrations of a single I2RT YAM arm picking up a blue duster and placing it in a red box, 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 200 takes as Dimios45/yam-pick-duster-200, 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	200
Frames	30,523 @ 10 Hz (50.4 min)
Episode length	109–280 frames (10.8–27.9 s), median 14.5 s
Robot	I2RT YAM, 6-DoF + linear_4310 gripper, right arm only
Cameras	top_image, wrist_image — both 640×480 RGB, uncropped
Task	pick the duster, place it in the box

Recorded in two sittings of 100 on 2026-08-17/18.

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.

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.
• 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; a real model difference, not numerical noise, and not a fixed offset you can subtract 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 its Cartesian path without resolving the discrepancy — drive the arm in joint space instead, with FK/IK from the same model the data was recorded with.

Data quality

• 86% of frames contain motion (range 64–94%). No idle or dead takes.
• Start pose repeatability: 0.08 / 0.33 / 0.11 mm std.
• Lighting stable: top-camera brightness std 2.4/255, per-50-episode medians 144.4 / 143.8 / 144.0 / 144.1.
• 198/200 episodes contain a grasp; two aborted takes (20260818T004003534366, 20260818T005359521504) never close the gripper.
• 14 episodes re-grasp after a failed first attempt — useful recovery data.

Both objects were repositioned between episodes:

	x range	y range	std
grasp (duster pickup)	0.35–0.60 m	−0.15 to +0.25 m	52 / 119 mm
release (into the box)	0.32–0.60 m	−0.14 to +0.25 m	63 / 123 mm

Median distance from the release point to the detected box centre is ~60 mm, so the drop tracks the box rather than being a fixed target. Release height averages 0.179 m, about 6 cm above the grasp height.

Loading

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

r = EpisodeReader(Path("20260818T020201002323"))
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

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.

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. Use --data-freq 10 --origin-time-scale 10 at rollout — this dataset is 10 Hz.

Deploying

A policy trained here emits Cartesian poses, so deployment needs inverse kinematics from the same model (see the caveat above). 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. Use 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 deadlock that does not recover.

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.

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's horizon is pose-dependent, so verify any wrist crop across the workspace. Whatever crop is used for training must be applied identically at deployment.

Licence

Apache-2.0.