PersistBench

A benchmark for object permanence under camera motion: does a model still know where an object is after the camera has looked away from it?

Each of the 2,086 evaluation pairs is built from a single 360° source clip by rendering two perspective camera trajectories through the same scene at the same timestamps:

view	role	object visibility
center/	reference — the object is tracked and visible	visible throughout
view_0/	query — the camera pans away and back	leaves and re-enters the frame

A model is given the query view and must localize the object across the interval in which it is off-screen. Because both views are rendered from the same equirectangular source with known camera parameters, ground-truth masks and full camera extrinsics are available for both views at every frame.

Two subsets differ in what the object itself does while out of view:

• dynamic/ (1,022 pairs) — the object keeps moving while off-screen. Tests extrapolation of motion, not just memory of a location.
• static/ (1,064 pairs) — the object is stationary while off-screen. Tests pure persistence.

Contents

shards/shard-####.tar        # the dataset, ~1.2 GB per shard, uncompressed
shards/checksums.json        # sha256 + byte size per shard
index.json                   # pair_id -> {shard, subset, n_frames}
pairs.csv                    # same mapping, flat CSV (one row per pair)
samples/                     # 4 pairs, unarchived, for inspection without downloading a shard
croissant.json               # Croissant 1.0 metadata incl. RAI fields

Every shard expands to the same tree, so extracting all of them into one directory yields the complete benchmark:

<subset>/<case_id>/<obj_id>/
  center/video.mp4              # H.264, 1024x768
  center/camera_params.npy      # {cam_poses: (T,4,4), cam_intrinsic: (3,3)}
  center/masks/*.png            # binary GT mask, one per frame
  view_0/video.mp4
  view_0/camera_params.npy
  view_0/masks/*.png            # GT for the query view, including while off-screen
  visibility_dict.npy           # per-frame visibility schedule (see below)
  theta_phi_values.npy          # per-frame camera yaw/pitch, degrees
  estimate_input_coverage.json  # optional; present for 1,616 of 2,086 pairs

T (frame count) varies per pair, from 208 to 301; read it from index.json or from the mask count. Masks are uint8 PNGs, 0 or 255, at video resolution.

visibility_dict.npy is the item that defines the task:

d = np.load('visibility_dict.npy', allow_pickle=True).item()
d['view_0_visibility']   # (T,) float, per-frame visible fraction in the query view; 0.0 == off-screen
d['view_1_visibility']   # (T,) bool, reference view
d['mode']                # 'overlap' | ...
d['window_ratio']        # fraction of the clip the object spends off-screen
d['window_move_ratio']   # how far the object travels while off-screen (dynamic subset)

Evaluate on the frames where view_0_visibility == 0. Those are the frames where the answer cannot be read off the input.

Usage

# everything (~11 GB)
huggingface-cli download persistbench-neurips26/PersistBench --repo-type dataset --local-dir .
for f in shards/shard-*.tar; do tar -xf "$f"; done

# or just look at the samples first
huggingface-cli download persistbench-neurips26/PersistBench --repo-type dataset --include 'samples/*' --local-dir .

import numpy as np, json, glob
from PIL import Image

pair = 'dynamic/<case_id>/<obj_id>'
vis  = np.load(f'{pair}/visibility_dict.npy', allow_pickle=True).item()
cam  = np.load(f'{pair}/view_0/camera_params.npy', allow_pickle=True).item()
mask = np.array(Image.open(sorted(glob.glob(f'{pair}/view_0/masks/*.png'))[0])) > 127

occluded = np.flatnonzero(vis['view_0_visibility'] == 0)   # frames to score

Verify integrity after download:

python -c "
import json,hashlib
for n,v in json.load(open('shards/checksums.json')).items():
    h=hashlib.sha256(open('shards/'+n,'rb').read()).hexdigest()
    print(n, 'OK' if h==v['sha256'] else 'MISMATCH')"

Provenance and licensing

Source clips are publicly available 360° videos from YouTube; the case_id retains the source video identifier so any clip can be traced to its origin. The distributed .mp4 files are derived renderings — perspective crops re-projected from the equirectangular source — not copies of the original videos.

• Annotations (masks, camera parameters, visibility schedules, theta_phi_values, coverage JSON) are released under CC BY-NC 4.0.
• Rendered video frames are redistributed for non-commercial research use only under the fair-use provisions applicable to derived research artifacts. Copyright in the underlying footage remains with the original uploaders.
• Takedown requests for any individual source clip will be honored; the affected pairs will be removed and the index updated.

Object masks originate from an automatic segmentation model followed by temporal propagation. There is no human annotation in this dataset, and therefore no annotator demographic data.

Known limitations

• Masks are model-generated and inherit that model's failure modes: thin structures, motion blur, and heavy compression artifacts are the common error sources. They are not human-verified.
• Source clips are skewed toward the categories that are well represented in consumer 360° video (vehicles, sports, urban scenes). Geographic and subject coverage is uncontrolled and is not a uniform sample of the world.
• Re-projection from equirectangular to perspective introduces resampling artifacts near the poles of the source sphere.
• Frame counts are not uniform across pairs; do not assume a fixed T.

Croissant

croissant.json at the root of this repository is the authoritative metadata: Croissant 1.0 with the RAI extension, validated with mlcroissant. (The Hub's auto-generated Croissant endpoint does not cover tar-sharded repositories; use the file in the repo.)