jcapmeil/cupflow-lerobot

CupFlow, for LeRobot / SmolVLA

A Franka FR3 rearranges six cups on a table from one shape into another (circle, rectangle, scatter, and right, isosceles and equilateral triangles). One episode is one whole run: the six pick-and-places that turn one shape into the next, under a single instruction such as "Make this circle of cups into a rectangle of them."

This is a LeRobotDataset v3.0, laid out to match the SmolVLA example dataset lerobot/svla_so100_pickplace: the same feature names and order (action, observation.state, observation.images.top, observation.images.wrist), 480×640 AV1 video at 30 fps, joints and gripper as the state and action, and one task string per episode. The differences come from the robot: 7 joints plus a gripper width (8 values, radians and metres) instead of the SO100's 5 joints plus gripper (6 values, degrees). Each episode runs from the instruction until the task it names is complete.

Size: 150 runs (900 placements), 604,188 frames at 30 fps (5.6 h), recorded 2026-09-18 to 2026-10-04. A run is 1.6 to 3.8 min long (2,893 to 6,859 frames, median 4,022).

A private sibling dataset, jcapmeil/cupflow-lerobot-goalpick, has the same recordings with one episode per cup, a per-cup instruction, and the goal and pick positions in the state. The conversion script for both is dataset/to_lerobot.py in the CupFlow repo (--runs for this one), written with lerobot 0.4.4.

Fine-tune SmolVLA

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=jcapmeil/cupflow-lerobot \
  --rename_map='{"observation.images.top": "observation.images.camera1", "observation.images.wrist": "observation.images.camera2"}' \
  --policy.repo_id=${HF_USER}/smolvla_cupflow \
  --batch_size=64 --steps=20000 \
  --output_dir=outputs/train/smolvla_cupflow --job_name=smolvla_cupflow \
  --policy.device=cuda

smolvla_base expects cameras named camera1..3, so --rename_map is required. A 3-step run of this command (batch 8, on Apple MPS) loads, trains and lowers the loss. To browse episodes, open it in the LeRobot dataset visualizer.

Features

Key	Shape	Meaning
observation.images.top	480×640×3 video	ZED 2i left eye, RGB, downscaled from 1920×1080 to 640×360 and letterboxed (black bars top and bottom) to 480×640. Fixed third-person view of the table
observation.images.wrist	480×640×3 video	RealSense on the gripper, RGB
observation.state	8 float32	joint_1..joint_7 (rad) + gripper_width (m)
action	8 float32	the same 8 one step later: absolute joint-position targets q(t+1/30 s) and the commanded gripper width
task	text	the run's instruction, e.g. "Make this circle of cups into a rectangle of them." (30 distinct)

That is everything SmolVLA reads, and nothing else is stored.

How the recordings were turned into runs

• Six placements per run, spliced. The rig recorded each cup as its own clip, with an unrecorded pause of about 2 s between clips (1.2 to 5.9 s). The arm is stationary across every join (largest joint change under 0.005 rad), so the clips are joined back to back with the pauses cut, and the seams are not visible.
• A 30 Hz grid. Within each clip, frames run from the moment all three streams (joint state, ZED, wrist camera) are live to the moment the first one stops. Joint angles are linearly interpolated from the 50 Hz state stream. Images are the latest frame at or before each grid time, never a later one.
• Gripper. The rig never logged a measured gripper width, so gripper_width is the last commanded width (0.067 m and similar when grasping, 0.08 m open), taken as open before the first command.
• Recorder stalls. Every placement has two stalls of about 1 s (median 0.96 s, max 1.66 s), at grasp and at release, when the recorder froze while the gripper command blocked. About 30 frames in a row then repeat. The arm did not move in any of the 1,800 stalls (largest joint change under 0.01 rad).
• ZED video was decoded straight from zed.svo2 (an MCAP file holding H.264), and its timestamps were checked against those logged with the joint states.
• Skipped: 1 of 151 recorded runs, rectangle_to_triangle_isosceles_20260918_182602, because one of its ZED clips does not decode in full (901 frames from 902 packets). Runs are only included complete. meta/cupflow_skipped.json gives the reason.
• Not included: depth, Vicon, torques, dynamics terms and the joint-velocity commands. They are in the raw recordings, which are not public.

Per-placement detail and splits

meta/cupflow_episodes.jsonl has one row per episode_index with:

• session: the raw run name; chain: runs that continue from one another's final layout share a chain
• camera_epoch: the ZED moved between 2026-09-28 and 2026-09-30, so 0 means before and 1 means after
• source_shape, target_shape, instruction
• placements: for each of the six cups, its frame range in the episode (from_frame, to_frame), cup and slot, the commanded place position goal_xy and the pick position pick_xy (robot_base frame, m), the per-cup instruction, grasp rung and resampling stats

LeRobot stores the task per frame, so per-cup instructions can be swapped in later from these ranges without touching the videos.

Episode 0 is rectangle_to_triangle_right_20260918_193000 (rectangle to right triangle), put first for the viewer because it has the longest cup move in the data, 0.59 m across the table. The rest are in recording order. To hold out whole runs or chains, select by these columns and pass the indices with --dataset.episodes='[...]'.

Things to know before training

• The policy has to read the scene. The instruction names the target shape, but each layout's position, rotation and scale on the table vary from run to run, so the policy has to infer where the next cup goes from the cups already placed. The first cup of a run has the most freedom.
• Action space. The FR3 was driven by joint-velocity commands. action uses the LeRobot convention instead, absolute joint-position targets. Deploying it needs a joint-position (or impedance) controller, or a P-controller that turns targets into velocities.
• Two camera epochs. The top (ZED) view changes from 2026-09-30 onward.
• Video decoding. Videos are AV1, which LeRobot decodes with torchcodec by default. If torchcodec can't load against your FFmpeg, pass --dataset.video_backend=pyav.

License

The license and citation will be added by the authors.

Contact: Jake Capmeil (via the Hugging Face profile that owns this dataset).