SceneMem evaluates whether vision-language-action (VLA) models can build a memory of where objects were placed during a long-horizon video and recall that memory on demand. In each scenario, a robot performs 5–7 kitchen tasks back to back in a single continuous ~6.5-minute video.

The dataset contains 839 scenarios and 7,260 memory-probe tests across three task types, with three synchronized camera views per scenario. Each scenario is constructed by stitching individual RoboCasa task demonstrations into a unified MuJoCo environment, with rule-based base-navigation transitions between tasks.

Supported Tasks

Each test carries a task field selecting one of three task types (see Evaluation for the success metric of each):

find_target — given a memory-probe instruction, identify and approach the fixture where the queried object was placed during the video, and open its door. Success metric: memory_success.
find_distractor — same probe and metric as find_target, but the queried object is a distractor: an object present inside a fixture in the scene that was never the target of a pick-and-place task. The model must recall its location from the video just the same. Success metric: memory_success.
restore — The model must return the object to its original (pre-video) pose. Success metric: restore_success.

Comparison with related benchmarks

Benchmark	Horizon (frames)	Multi-task per rollout	Memory eval
RoboCasa365	~1,500	✗ (1)	✗
CALVIN (LH-MTLC)	up to ~1,800	✓ (5)	✗
LIBERO-LONG	~600	✗ (1)	✗
MimicGen	~100–700	✗ (1)	✗
BridgeData V2	~38 avg	✗ (1)	✗
SceneMem	~7,776 avg	✓ (5–7)	✓

Languages

The dataset is in English. Memory-probe instructions follow two templates: "Show me where the {category} is placed." (for find_target / find_distractor) and "Put the {category} back where it was." (for restore).

Dataset Structure

scene-mem-benchmark/                                ~17 GB
├── README.md
├── eval/
│   ├── success_fn.py                              # memory_success (find) + restore_success (restore)
│   ├── base_policy.py                             # BasePolicy abstract interface
│   ├── tasks.py                                   # EVAL_TASKS registry: per-task max_steps + check fn
│   └── eval_runner.py                             # env load + rollout + metric aggregation
└── data/
    └── combo_<id>_L<layout>_S<style>_<seed>/      ~26 MB each
        ├── eval_spec.json                          # per-test metadata: task, target, fixture/source_pose, language
        ├── videos/
        │   ├── robot0_agentview_left.mp4           # 256×256, 20 fps, ~6.5 min
        │   ├── robot0_agentview_right.mp4
        │   ├── robot0_eye_in_hand.mp4
        │   └── subtasks.json                       # per-task frame segments, is_pnp/is_transit flags, instructions
        └── env/
            ├── unified_model.xml                   # MuJoCo XML
            ├── env_args.json                    
            ├── ep_meta.json                        # layout/style — MUST apply via env.set_ep_meta() before reset
            └── start_state.npy

Each test in eval_spec.json carries a task field (find_target / find_distractor / restore):

find_target / find_distractor tests have a fixture block (body_name + joint_names) — the destination to approach and open.
restore tests instead carry a source_pose ([x, y, z, qw, qx, qy, qz] snapshot of the object's pre-video pose) and a success block ({tol, check_quat}).
A small number of find_target tests are compound (carry a members list of fixtures instead of one fixture); the policy must visit every member in a single rollout.

eval_runner.py consumes eval_spec.json automatically — direct access is only needed for custom analysis. The 5-step env-loading pattern (set_ep_meta → reset → reset_from_xml_string → sim.reset → set_state_from_flattened) is shown in Setup; in particular, ep_meta.json must be applied before the first env.reset() or the layout will not match unified_model.xml.

Statistics

Metric	Value
Total scenarios	839
Unique task combinations	33
Kitchen layouts	16
Kitchen styles	19
Distribution (PnP, aux) tasks	(3,3): 405 / (3,4): 293 / (3,2): 133 / (3,1): 8
Total eval tests	7,260
– find_target	2,737
– find_distractor	1,487
– restore	3,036
Avg. eval tests per scenario	8.65
Unique PnP task classes	21
Unique auxiliary tasks	137
Frame rate	20 fps
Render resolution	256 × 256
Video length range	4,325 – 10,970 frames (avg ~7,776, ~6.5 min)
Robot	PandaOmron (Franka arm + Omron mobile base)

Eval tests by destination fixture type

restore tests have no fixture (success is defined by source_pose), so they are omitted here. Two find_target tests are compound (multiple fixtures) and are also omitted.

Fixture	find_target	find_distractor
microwave	792	445
cabinet	590	351
toaster_oven	413	0
freezer	290	4
fridge	194	571
oven	166	50
sink	152	0
dishwasher	138	66
Total	2,735	1,487

Setup

SceneMem requires robosuite and RoboCasa. Follow RoboCasa's installation instructions (which also installs robosuite, MuJoCo, and other dependencies), then clone this benchmark:

git clone <THIS_REPO_URL> scene-mem-benchmark
cd scene-mem-benchmark

To sanity-check the install, load one scenario:

import json, numpy as np, robosuite, robocasa  # noqa: F401

sdir = "data/combo_002_L29_S48_0016"  # any scenario
spec = json.load(open(f"{sdir}/eval_spec.json"))

env_args = json.load(open(f"{sdir}/env/env_args.json"))
xml      = open(f"{sdir}/env/unified_model.xml").read()
ep_meta  = json.load(open(f"{sdir}/env/ep_meta.json"))
kw = dict(env_args["env_kwargs"])
kw["has_renderer"] = False
kw["has_offscreen_renderer"] = True
kw["use_camera_obs"] = True
# The unified robocasa env only exposes robot0_* cameras (no bare "agentview",
# robosuite's default when camera_names is unset → ValueError at reset). Pin the
# three that match the deployed prior-task videos.
kw.setdefault("camera_names",
              ["robot0_agentview_left", "robot0_agentview_right", "robot0_eye_in_hand"])
kw.setdefault("camera_heights", 256)
kw.setdefault("camera_widths", 256)
env_name = kw.pop("env_name", env_args["env_name"])

env = robosuite.make(env_name, **kw)
env.set_ep_meta(ep_meta)
env.reset()
env.reset_from_xml_string(env.edit_model_xml(xml))
env.sim.reset()
env.sim.set_state_from_flattened(np.load(f"{sdir}/env/start_state.npy"))
env.sim.forward()
print("OK, scenario loaded:", spec["scenario"])

Usage

Implementing a policy

Subclass BasePolicy (in eval/base_policy.py). The interface is observation-agnostic — the runner hands you the live env and you pull whatever cameras / proprio your model wants. Place my_policy.py inside eval/ (the runner puts that directory on sys.path and imports your policy as module:Class):

# eval/my_policy.py
from base_policy import BasePolicy
import numpy as np

class MyPolicy(BasePolicy):
    def __init__(self):
        # load your VLA model here
        ...

    def reset(self, instruction: str, video_paths: list[str]) -> None:
        # called once at the start of each rollout
        # video_paths: 3 prior-task videos (agentview_left/right, eye_in_hand)
        # instruction: e.g. "Show me where the bowl is placed."
        self.instruction = instruction
        self.context = load_videos(video_paths)  # your code

    def get_action(self, env) -> np.ndarray:
        # called every env step; return an action of shape env.action_dim
        obs = env._get_observations()  # or pull specific keys
        return self.model.predict(obs, self.instruction, self.context)

Running evaluation

python eval/eval_runner.py \
    --data_dir data/ \
    --policy my_policy:MyPolicy \
    --tasks find_target \
    --out results.json

--tasks selects which task types to run: a comma-separated subset of find_target,find_distractor,restore, or all. It defaults to find_target only — pass --tasks all to evaluate the full benchmark.

Optional --filter <substring> restricts the run to scenarios whose directory name contains the substring (handy for smoke testing).

results.json contains per-test outcomes (tagged by task) and a per-task rollup:

{
  "results": [
    {
      "scenario": "combo_002_L29_S48_0016",
      "tests": [
        {"test_id": "RestockBowls_obj1", "task": "find_target", "success": true},
        {"test_id": "restore_MicrowaveThawing_obj", "task": "restore", "success": false}
      ]
    }
  ],
  "summary": {
    "total": 7260, "success": 3142,
    "by_task": {
      "find_target":     {"success": 1342, "total": 2737},
      "find_distractor": {"success":  701, "total": 1487},
      "restore":         {"success": 1099, "total": 3036}
    }
  }
}

Notes

Per-test rollouts are independent: each test starts from start_state.npy and runs at most max_steps steps. The budget is per-task (see eval/tasks.py): find_target / find_distractor = 1000, restore = 1500.
BasePolicy does not impose an observation format — different VLAs disagree on input layout, so baking one in would just force adapter code.

Evaluation

Each task type has its own success checker (dispatched via the EVAL_TASKS registry in eval/tasks.py; see eval/success_fn.py for the implementations).

find_target / find_distractor:

memory_success = approached_fixture ∧ door_open

Component	Measurement	Threshold
`approached_fixture`	xy distance between `mobilebase0_support` and `fixture.body_name`	< 1.2 m
`door_open`	for any joint in `fixture.joint_names`, `\|qpos\|` exceeds threshold	≥ 0.5 (rad for hinge, m for slide)

door_open is vacuously true when fixture.joint_names is empty (e.g. sink, open cabinet) — the approach check alone determines success.

For these two tasks the benchmark measures recall, not manipulation skill: a full pick-and-place rollout would conflate grasp/place success (a separate skill problem) with the actual memory signal we want to evaluate.

restore:

restore_success = object returned to within tol of its pre-video pose

Component	Measurement	Threshold
position	distance between `target.body_name` `body_xpos` and `source_pose[:3]`	< `tol` (default 0.1 m)
orientation	only if `check_quat`: angle between current quat and `source_pose[3:7]`	≤ ~20°

Unlike the find tasks, restore does require a full pick-and-place (open door → grasp → carry → release), so it carries manipulation noise; tol and the step horizon are tuned empirically per test (eval_spec.json's success block).

License

TODO

Downloads last month: 27

Total file size:

22.2 GB