This dataset has 50 scripted expert demonstrations of a RoboTwin 2.0 memory task with a long delay. The only memory cue is shown during the first 66 frames (about 4 s). The robot then spends about two minutes on a cue-independent cleanup, and must reproduce the cue at the end. When recall starts, a memory made of the most recent 15 s, 20 s or 60 s of frames holds no frame of the cue. The task is meant to expose failure cases of policies whose memory is a recency window of uniformly sampled frames.

The task code is in task/, and its task page follows the RoboDojo format (task/README.md).


Simulator	RMBench (RoboTwin 2.0 memory fork), SAPIEN, CuRobo planner
Embodiment	aloha-agilex (two 6-DoF arms with parallel grippers)
Config	`demo_clean`, `save_freq: 15` (one frame every 15 steps of the 250 Hz sim, 16.7 frames per simulated second)
Episodes	50, seeds 0–49. The expert succeeded on all 50 seeds it tried
Length	2899–2942 frames (mean 2920); about 175 s of simulated time
Cue	Frames 0–65
Cue → first recall step	2345–2378 frames
Cameras	head, left wrist, right wrist, third view; 320×240 RGB, stored as JPEG
Size	9.9 GB of HDF5 plus 69 MB of head-camera MP4

The task

Instruction: Remember the color order on the display. Hand every gray block from the left arm to the right arm via the black pad into the bin, then put the colored blocks on the yellow pads in that order, left to right.

Phase	Frames	Depends on cue?
Cue: a display at the back of the table shows red, green and blue tiles in a random left-to-right order while the robot holds still; then a shutter closes and the tiles disappear	0 – 65	is the cue
Cleanup: six gray blocks, each put on the black pad by the left arm and dropped into the bin by the right arm	66 – ~2425	no
Recall: the right arm puts the red, green and blue blocks on the three yellow pads in the displayed order, then both arms return home	~2425 – end	yes

From the moment the shutter closes until recall starts, nothing depends on the cue: the layout, the cleanup order, the expert motion and the language annotations are the same for all six orders. The cue is drawn independently of the layout.

Scoring (eval): 0 → 5 (half of the gray blocks in the bin) → 15 (all in the bin) → 30 (first pad correct) → 60 (two pads correct) → 100 (all three correct, everything at rest, grippers open, arms home). Moving a colored block before the cleanup is done, or placing a wrong color, ends the episode's scoring. A policy that does the cleanup perfectly but has to guess the order succeeds 1/6 of the time and scores about 31.7 on average.

Why recency-window memories fail

The same frames are read at different rates by different pipelines: 15 Hz is the frequency the HDF5 declares, 16.7 Hz is the simulated clock, and 30 Hz is the MP4 rate and XPolicyLab's default eval rate.

	15 Hz	16.7 Hz	30 Hz
Episode length	193–196 s	174–177 s	97–98 s
Cue → first recall step	156–159 s	141–143 s	78–79 s

Even in the shortest case (30 Hz), the gap is about 30% longer than a 60 s window.

Files

README.md
data/episode_0000000.hdf5 … episode_0000049.hdf5   one HDF5 file per episode
video/episode_0000000.mp4 … episode_0000049.mp4    head camera, H.264, 320×240, 30 fps
instruction/episode_0000000.json …                 instructions sampled for each episode ("seen" / "unseen")
language_annotation.json                           per-episode segments: [[text, n_frames], ...]
scene_info.json                                    per-episode cue_order, color_slots, chore_blocks
seed.txt                                           the 50 seeds
task/                                              task code, instructions, install and check scripts, offline tests

The files keep RMBench's layout. To use them with RMBench, put them under RMBench/data/demo_clean/recall_order_after_cleanup/aloha_agilex/. The planner trajectory cache (_traj_data/, pickles) is not included. It can be rebuilt by collecting the same seeds again.

HDF5 layout

Each file holds T steps, one fewer than the episode's frame count (action[t] equals state[t+1]).

Key	Shape	Contents
`state/{left,right}_arm_joint_states`	(T, 6) float32	Arm joint positions
`state/{left,right}_ee_joint_states`	(T, 1) float32	Gripper opening, 0 (closed) to 1 (open)
`state/{left,right}_ee_poses`	(T, 7) float32	End-effector position (3) and quaternion (4)
`action/...`	same as `state/...`	Next-step targets
`vision/{cam_head,cam_left_wrist,cam_right_wrist,cam_third_view}/colors`	(T,) bytes	JPEG-encoded 320×240 frames
`vision/<cam>/intrinsic_matrix`, `extrinsics_matrix`	(T, 3, 3), (T, 4, 4)	Camera parameters per step
`instructions`	scalar	JSON list of the instruction strings
`additional_info/frequency`	scalar	15

import h5py, numpy as np, cv2

with h5py.File("data/episode_0000000.hdf5", "r") as f:
    qpos = f["state/left_arm_joint_states"][:]                      # (T, 6)
    jpeg = f["vision/cam_head/colors"][0]
    rgb = cv2.imdecode(np.frombuffer(jpeg, np.uint8), cv2.IMREAD_COLOR)[..., ::-1]  # (240, 320, 3)

Only the head camera sees the display. The third-view camera looks at it from behind, so RMBench's eval videos, which use that camera, cannot show the cue.

Metadata

scene_info.json, e.g. "episode_0": {"cue_order": ["red", "green", "blue"], "color_slots": {"red": 1, "green": 0, "blue": 2}, "chore_blocks": 6, ...}. cue_order is the answer. It is for analysis only and must not be given to a policy.
language_annotation.json: segment-level subtask texts with frame counts, in episode order. The first segment ("Watch the display and memorize the color order from left to right.", 66 frames) is the cue. The cleanup segments are the same for every order. The recall segments name the block and the pad, e.g. "Place the red block on the left yellow pad.", so they contain the answer. Use them as training labels, but never give them to a policy at eval time. The episode instructions (instruction/, HDF5 instructions) never mention colors.

Checks on this collection

task/scripts/check_timeline.py: at every one of the three frame rates, the 15 s, 20 s and 60 s windows miss the cue at the first recall step for all 50 episodes. Each HDF5's length agrees with its annotations.
task/scripts/audit_cue_balance.py: tests whether the kept episodes let the layout predict the cue. All three chi-square tests pass at p = 0.001. Cue orders rgb 8, rbg 8, grb 7, gbr 13, brg 8, bgr 6 (χ² 3.5, critical 20.7). Starting slot of the left-pad block: 21 / 15 / 14 (χ² 1.7, critical 14.1). Cue vs layout: χ² 29.3, critical 52.7, which has little power with 50 episodes. Since the expert never failed, seed filtering removed nothing.
Decoded head-camera frames: in all 50 episodes, the largest change between frames 63 and 67 is between frames 65 and 66, when the shutter closes.

Reproduce or collect more

bash task/scripts/install_task.sh /path/to/RMBench
cd /path/to/RMBench && bash collect_data.sh recall_order_after_cleanup demo_clean 0

install_task.sh also writes control configs with a shorter delay (demo_clean_chore0, demo_clean_chore2, demo_clean_chore4) and a config whose cue starts later (demo_clean_onset2), to guard against memories that always keep frame 0. Collection needs CUDA. On one RTX 6000 Ada it took about 4 h for 50 episodes. Pin ffmpeg=5.1 from conda-forge, since an unpinned install can break video writing.

Caveats

Recall annotations contain the answer: the recall segments of language_annotation.json name each color's pad, and so does cue_order in scene_info.json. Neither may reach a policy at eval time.
Seed exposure: the cue is a function of the episode seed. Policy servers must not use the seed.
Frame-0 anchoring: a memory that always keeps the first frame sees the cue. Use demo_clean_onset2 to test this.
Writing the cue into the scene: moving a colored block during the cue counts as a failure. Subtler channels, such as which gray block goes first, cannot be closed by scoring. The expert does nothing cue-dependent before recall, so imitation gives no signal for them.

Downloads last month: 52

Total file size:

10.6 GB