Extension of MemoryBench with additional memory-dependent manipulation tasks. The original three MemoryBench tasks (put_block_back, reopen_drawer, rearrange_block) are not duplicated here — download those from hqfang/memorybench.

Task: stack_and_swap

Two identically colored blocks (A, B) start on two colored patches. The robot must:

Pick block A and place it at the center.
Pick block B and stack it on top of A at the center.
Press a button (memory separator).
Unstack block B and place it on patch A (block A's original spot).
Pick block A from the center and place it on patch B (block B's original spot).

The blocks end with their positions swapped, having passed through a stacking intermediate state. The button press separates the "stack" phase from the "swap" phase, requiring the policy to remember each block's original patch across the separator.

Variations: 2 (which block starts on which patch)
Episode length: ~430–450 timesteps
Image size: 128×128
Cameras: front, left_shoulder, right_shoulder, wrist, overhead (RGB + depth + mask)
Language description: "Stack the blocks at the center, press the button, then swap each block to the other's original patch"

Task: blocks_in_drawers

Two identically colored blocks spawn at randomized positions on the table in front of a 3-level drawer unit. The robot must place each block in a different drawer and close all drawers. The assignment of blocks to drawers is the robot's own choice.

The instruction is drawer-agnostic — it does not name a drawer or block. Once a drawer is closed after a placement, the scene gives no persistent visual cue about which drawer was already used. The policy must remember its own prior drawer choice to pick a different drawer for the second block.

Variations: 6 (ordered pairs of 2 drawers from {bottom, middle, top})
Image size: 128×128
Cameras: front, left_shoulder, right_shoulder, wrist, overhead (RGB + depth + mask)
Language description: "put each of the two blocks in a different drawer and close the drawers"

Task: blocks_in_drawers_hard

Three identically colored blocks spawn at randomized positions on the table in front of a 3-level drawer unit. The robot must place each block in a different drawer and close all drawers. Each drawer can hold at most one block; the assignment of blocks to drawers is the robot's own choice.

Variations: 6 (ordered triples of 3 drawers from {bottom, middle, top})
Image size: 128×128
Cameras: front, left_shoulder, right_shoulder, wrist, overhead (RGB + depth + mask)
Language description: "put each of the three blocks in a different drawer and close the drawers"

Task: inspect_and_pick

Three differently colored blocks (red, green, blue) start hidden inside a 3-level drawer unit, one per drawer. The robot must:

Open each drawer in turn (top, middle, bottom), exposing the colored block briefly to the cameras, then close it.
Press a button.
Open the drawer holding the red block, pick it up, drop it in a box on the table, and close that drawer.

The instruction does not name the source drawer for the red block. By the time the button is pressed, every drawer is closed and the scene gives no persistent visual cue to which drawer held the red block.

Variations: 6 (permutations of red, green, blue over the bottom, middle, top drawers)
Image size: 128×128
Cameras: front, left_shoulder, right_shoulder, wrist, overhead (RGB + depth + mask)
Language description: "inspect each drawer, press the button, then pick the red block and put it in the box"

Layout

data/
├── train/
│   ├── stack_and_swap.zip            # 100 demonstrations
│   ├── blocks_in_drawers.zip         # 100 demonstrations
│   ├── blocks_in_drawers_hard.zip    # 100 demonstrations
│   └── inspect_and_pick.zip          # 100 demonstrations
├── test/
│   ├── stack_and_swap.zip            # 25 demonstrations
│   ├── blocks_in_drawers.zip         # 25 demonstrations
│   └── blocks_in_drawers_hard.zip    # 25 demonstrations
└── files/
    ├── stack_and_swap.py             # RLBench task definition
    ├── stack_and_swap.ttm            # CoppeliaSim scene file
    ├── blocks_in_drawers.py
    ├── blocks_in_drawers.ttm
    ├── blocks_in_drawers_hard.py
    ├── blocks_in_drawers_hard.ttm
    ├── inspect_and_pick.py
    └── inspect_and_pick.ttm

Each zip unpacks to <task>/all_variations/episodes/episode<N>/ matching the standard PerAct/RLBench dataset layout.

Usage

# Download
hf download phanikiran1169/memorybench-extended --repo-type dataset --local-dir ./mbe

# Unzip into your data_memory/ tree
mkdir -p data_memory/train data_memory/test
unzip -q ./mbe/data/train/stack_and_swap.zip         -d data_memory/train/
unzip -q ./mbe/data/train/blocks_in_drawers.zip      -d data_memory/train/
unzip -q ./mbe/data/train/blocks_in_drawers_hard.zip -d data_memory/train/
unzip -q ./mbe/data/train/inspect_and_pick.zip       -d data_memory/train/
unzip -q ./mbe/data/test/stack_and_swap.zip          -d data_memory/test/
unzip -q ./mbe/data/test/blocks_in_drawers.zip       -d data_memory/test/
unzip -q ./mbe/data/test/blocks_in_drawers_hard.zip  -d data_memory/test/

# Install task files into your RLBench fork
cp ./mbe/data/files/stack_and_swap.py          <rlbench>/rlbench/tasks/
cp ./mbe/data/files/stack_and_swap.ttm         <rlbench>/rlbench/task_ttms/
cp ./mbe/data/files/blocks_in_drawers.py       <rlbench>/rlbench/tasks/
cp ./mbe/data/files/blocks_in_drawers.ttm      <rlbench>/rlbench/task_ttms/
cp ./mbe/data/files/blocks_in_drawers_hard.py  <rlbench>/rlbench/tasks/
cp ./mbe/data/files/blocks_in_drawers_hard.ttm <rlbench>/rlbench/task_ttms/
cp ./mbe/data/files/inspect_and_pick.py        <rlbench>/rlbench/tasks/
cp ./mbe/data/files/inspect_and_pick.ttm       <rlbench>/rlbench/task_ttms/

References

Original MemoryBench: https://huggingface.co/datasets/hqfang/memorybench
SAM2Act: https://github.com/sam2act/sam2act
RLBench: https://github.com/stepjam/RLBench

Downloads last month: 68

Total file size:

135 GB