scene-mem-benchmark

A benchmark for scene memory in embodied agents: an agent watches a mobile manipulator work in a house for several minutes, then is asked to retrieve an object it has to remember — one that was moved, dropped, or merely seen along the way.

Episodes are generated in ManiSkill / MuJoCo on AI2-THOR-derived houses with a mobile Franka Panda.

Episodes	153 across 79 houses
Total length	17.2 hours (median 7.0 min/episode, min 2.6, max 11.9)
Queries	759 scorable (382 find_target / 377 find_distractor)
Cameras	3 × 640×480 @ 25 fps (two exocentric, one wrist)
Size	~41 GB

Layout

data/<house>__<seed>/
├── videos/
│   ├── exo_camera_1.mp4      # 640×480, 25 fps, H.264
│   ├── exo_camera_2.mp4
│   └── wrist_camera.mp4
├── traj.h5                   # actions + proprioception, per simulation step
├── subtasks.json             # two-level subtask segmentation + instructions
├── eval_spec.json            # ★ the memory queries and their answers
├── final_state.npz           # object poses at context end — seeds the eval episode
└── meta.json                 # house, seed, fps, camera list, scene fingerprint

Frame indices in subtasks.json and eval_spec.json index the videos and traj.h5 alike; everything is on the same 25 fps clock.

eval_spec.json — the actual benchmark

Each query asks the agent to pick up an object, described only by category, after the context video has ended. There are two axes.

kind — where the answer lives.

• find_target — the object was moved by the robot during the context. Answering requires remembering the manipulation, not just the initial scene.
• find_distractor — the object was never touched; it was only seen in passing. This tests incidental scene memory and guards against agents that only track what the robot handled.

steps — how many objects answer the query.

• single (684) — one answer.
• multi (75) — every answer must be picked up once within a single rollout. Order is not scored.

Other fields worth knowing:

field	meaning
query	the instruction shown to the agent
answers[]	ground-truth objects: body id, xyz at context end, room, surface, visibility stats
scoring	lifted (634) — success requires actually lifting; reached_only (125) — the object is not liftable by the planner in the end state, so reaching it counts
n_candidates	how many objects of that category exist in the scene
twin_nearby	an identical twin sits within 26 cm — grading uses body id, never category
misplaced	no / on_floor / wrong_surface — whether the answer ended up somewhere unusual
concealment	whether the object was visible or hidden inside a fixture at context end
eligible	always true — queries that failed validation were removed (see below)

Grading always compares the grasped body id. Category matching is not sufficient: scenes routinely contain identical twins 26 cm apart.

Selection

Episodes here are those with ≥3 scorable queries (eligible: true and scoring != "unknown"), selected from 176 generated. The number of answerable queries — not episode length, not the count of successful robot events — is what separates usable episodes from empty ones. Thresholding on length or on successful events was tried and discarded: it lets through episodes with nothing to ask about while dropping ones that are perfectly usable.

Two integrity checks are applied on top. An episode is dropped if any of its eight files is missing (three episodes lost their exocentric videos during generation), and if it runs under one minute (two 24-second episodes cleared the query threshold but hold no context worth remembering).

Within an episode, queries that failed validation were removed rather than shipped with a flag, so every query in queries[] is scorable. Each removal is recorded in dropped_ineligible (name, kind, reason) at the top of the file. 27 queries were dropped this way, all because the robot never actually observed the answer object — asking "the one from earlier" about something that never appeared on camera is not a memory question. A further 50 were dropped earlier as ambiguous (dropped_ambiguous), where a distractor query's wording collided with a target's.

The observation threshold behind those 27 (≥1.0 s of cumulative visibility at ≥50 px) is provisional. If you want them back, they are recoverable from the generation-side artifacts without regenerating any data.

Note that a query can be answerable even when the robot's own attempt failed. Roughly 42% of scripted events fail (grasp planning finds no solution, the object slips, a drawer sticks), and those failures still leave a well-defined object in a well-defined place to ask about. 397 of 671 events succeeded across the released episodes.

traj.h5

One group per trajectory (traj_0), following the ManiSkill trajectory format:

traj_0/
├── actions/{commanded_action, ee_pose, ee_twist, joint_pos, joint_pos_rel}
├── obs/agent/{qpos, qvel}
├── obs/extra/{env_states, policy_phase, policy_num_retries, …}
├── obs/sensor_param/<camera>/{intrinsic_cv, extrinsic_cv, cam2world_gl}
├── env_states/articulations/panda
└── {rewards, success, terminated, truncated, fail}

Camera intrinsics and extrinsics are stored per frame, so the exocentric views can be lifted to world coordinates and lined up against the ground-truth object poses.

Images are not in the h5 — they are in the mp4s, at the same frame indices.

subtasks.json

Two levels, with deliberately different field names so training targets do not blur:

• L1 subtasks[] — one entry per event, using task_description. Navigation to the docking pose is inside the subtask, so the count matches the number of tasks in the context.
• L2 segments[] — cut at base motion, using instruction taken verbatim from the upstream task templates. Three kinds only: nav (moving empty-handed), carry (moving while holding), manip (arm only, base parked). manip segments carry robot_base_pose.

outcome on each subtask records what actually happened (ok, failed_dropped, failed_no_plan, …) — failures are kept, not hidden.

Loading

from huggingface_hub import snapshot_download
import json, h5py

root = snapshot_download("Keh0t0/scene-mem-benchmark", repo_type="dataset")

spec = json.load(open(f"{root}/data/val_101__0/eval_spec.json"))
for q in spec["queries"]:
    if q["eligible"] and q["scoring"] != "unknown":
        print(q["query"], "->", [a["obj"] for a in q["answers"]])

with h5py.File(f"{root}/data/val_101__0/traj.h5") as f:
    print(f["traj_0/obs/agent/qpos"].shape)

To pull a single episode instead of all 41 GB:

snapshot_download("Keh0t0/scene-mem-benchmark", repo_type="dataset",
                  allow_patterns="data/val_101__0/*")

Known issues

On 23 of the 759 queries, the query-level misplaced field is a list such as ["no", "on_floor"] rather than a string. These are all steps: multi queries whose answers disagree — one object ended up on the floor, another did not — and the query-level field is a summary of the per-answer values. The remaining 736 queries carry a plain string there, so code like q["misplaced"] == "on_floor" or grouping by that field will misbehave on these 23.

answers[i].misplaced is always a string and always authoritative. Read the per-answer field.