Keh0t0/scene-mem-benchmark

Dataset Card for SceneMem

Dataset Summary

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 ~7-minute video. Afterwards the model is given a memory-probe instruction such as "Show me where the bowl is placed.", and must navigate to the correct fixture and open its door — purely from memory of the prior video.

The dataset contains 858 scenarios and 2,795 memory-probe tests, 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

• Scene-memory retrieval : given a long observation video and a memory-probe instruction, identify and approach the fixture containing the queried object. Success metric: memory_success (see Evaluation).

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	~8,170 avg	✓ (5–7)	✓

Languages

The dataset is in English. Memory-probe instructions follow the template "Show me where the {category} is placed."

Dataset Structure

scene-mem-benchmark/                                ~18 GB
├── README.md
├── eval/
│   ├── success_fn.py                              # memory_success = approached ∧ door_open
│   ├── base_policy.py                             # BasePolicy abstract interface
│   └── eval_runner.py                             # env load + rollout + metric aggregation
└── data/
    └── combo_<id>_L<layout>_S<style>_<seed>/      ~20 MB each
        ├── eval_spec.json                          # per-test metadata: target object, fixture body/joint, language
        ├── videos/
        │   ├── robot0_agentview_left.mp4           # 256×256, 20 fps, ~7 min
        │   ├── robot0_agentview_right.mp4
        │   ├── robot0_eye_in_hand.mp4
        │   └── subtasks.json                       # optional: per-task frame segments + 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              

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	858
Unique task combinations	34
Kitchen layouts	17
Kitchen styles	19
Distribution (PnP, aux)	(3,3): 434 / (3,4): 390 / (3,2): 34
Total eval tests	2,795
Avg. eval tests per scenario	3.26
Unique PnP task classes	21
Unique auxiliary tasks	141
Frame rate	20 fps
Render resolution	256 × 256
Video length range	7,171 – 9,732 frames (avg ~8,170, ~6.8 min)
Robot	PandaOmron (Franka arm + Omron mobile base)

Eval tests by destination fixture type

Fixture	Tests
microwave	811
cabinet	593
toaster_oven	430
freezer	290
fridge	209
oven	170
sink	152
dishwasher	142
Total	2,797

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
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:

# my_policy.py
from eval.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 \
    --out results.json

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

results.json contains per-test outcomes and an aggregate count:

{
  "results": [
    {
      "scenario": "combo_002_L29_S48_0016",
      "tests": [
        {"test_id": "RestockBowls_obj1", "memory": true},
        {"test_id": "MicrowaveThawing_obj", "memory": false}
      ]
    }
  ],
  "summary": {"total": 2795, "memory": 1342}
}

Notes

• Per-test rollouts are independent: each test starts from start_state.npy and runs at most max_steps steps (default 1500).
• BasePolicy does not impose an observation format — different VLAs disagree on input layout, so baking one in would just force adapter code.

Evaluation

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)

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. (See eval/success_fn.py for the implementation.)

License

TODO