Kirito-Lab/OPIS-dataset

OPIS Dataset

OPIS is an input-grounded benchmark for evaluating multi-object memory in image-to-video and camera-conditioned video world models. It anchors every evaluation to the fixed object instances visible in the initial image, rather than to a generated history or a prescribed reference video.

This repository contains the dataset release associated with the OPIS arXiv preprint:

OPIS: An Input-Grounded Benchmark for Multi-Object Memory in Video World Models

The benchmark is designed to measure whether a generated rollout preserves the objects established by its input. Its evaluator reports three complementary dimensions: Presence (whether observable instances are accounted for), Identity (whether the particular input instances are preserved), and Structure (whether their geometry or structural properties persist).

The original vector-quality figure is also included as assets/fig2.pdf.

Dataset summary

Item	Value
Cases	500
Scene domains	3
Subcategories	10
Addressable object instances	12,672
Static-geometry instances	6,128
Dynamic-structure instances	6,544
Reference image resolution	1280 × 720 RGB
Case index range per subcategory	0001–0050

The three scene domains are:

Directory	Domain	Subcategories	Cases
01_real_world_scene	Real-world scenes	home_indoor, natural_outdoor, public_indoor, urban_outdoor	200
02_robot_embodied	Embodied and robotic environments	industrial_robot_env, robot_lab_setup, simulated_environment	150
03_game_virtual_world	Game and virtual worlds	Cartoon_style_3D, Pixel_style_3D_sandbox, Realistic_style_3D_world	150

Each of the ten subcategories contains 50 cases. Case IDs and image names use the stable convention <subcategory>_<four_digit_index>, for example home_indoor_0001 or Cartoon_style_3D_0042.

Sources and construction

The benchmark combines real-world imagery, game screenshots, simulator-rendered scenes, and generated images. The source families described in the associated paper include Visual Genome, ADE20K, COCO images indexed through RefCOCO, BridgeData V2, IndustryShapes, gameplay collections such as Minecraft and SuperTuxKart, locally rendered AI2-THOR scenes, and images generated with gpt-image-2.5-sunburst.

All cases are converted to a common input-grounded format. A VLM-assisted selection and noun-phrase cleaning stage is followed by instance segmentation, appearance embedding extraction, mobility/kinematic annotation, geometric reference construction, task-prompt creation, and case-level human review. The released directory contains the resulting benchmark artifacts; it is not a collection of generated continuation videos.

Repository layout

OPIS-dataset/
├── metadata.jsonl              # one JSON record per case (500 records)
├── metadata_summary.json       # dataset-wide counts and naming convention
├── assets/
│   ├── fig2.pdf                # original paper figure
│   └── fig2.png                # page preview used above
├── <domain>/
│   └── <subcategory>/<case_id>/
│       ├── <case_id>.jpg
│       ├── noun_phrases.txt
│       ├── text_prompt.txt
│       ├── reference_scene.json
│       ├── reference_geometry.npz
│       └── assets/
│           ├── preprocessed/raw_1280x720.png
│           ├── masks/ref_*.png
│           └── crops/ref_*.png

Here <domain> is one of 01_real_world_scene, 02_robot_embodied, or 03_game_virtual_world. The three domain directories each contain the same two-level <subcategory>/<case_id> case layout.

Manifest fields

metadata.jsonl is a line-delimited JSON manifest. Each record contains:

• case_id: stable case identifier;
• category: one of real_world_scene, robot_embodied, or game_virtual_world;
• subcategory: one of the ten subcategories listed above;
• final_case_path: path to the complete case directory relative to the dataset root;
• image_path: path to the 1280 × 720 initial image;
• noun_phrases_path: path to the case-level noun-phrase list;
• annotation.noun_phrases: cleaned object concepts used to construct the reference inventory;
• annotation.object_count: number of annotated object instances;
• annotation.status: annotation status (annotated in this release);
• image: image format, color mode, and dimensions;
• schema_version: public manifest schema version.

Example:

{
  "case_id": "home_indoor_0001",
  "category": "real_world_scene",
  "subcategory": "home_indoor",
  "final_case_path": "01_real_world_scene/home_indoor/home_indoor_0001",
  "image_path": "01_real_world_scene/home_indoor/home_indoor_0001/home_indoor_0001.jpg",
  "noun_phrases_path": "01_real_world_scene/home_indoor/home_indoor_0001/noun_phrases.txt",
  "annotation": {
    "noun_phrases": ["wooden table", "chair"],
    "noun_phrase_count": 2,
    "object_count": 14,
    "status": "annotated"
  },
  "image": {"format": "JPEG", "mode": "RGB", "size": [1280, 720]},
  "schema_version": "final-public-v1"
}

Case-level artifacts

Initial image and task instruction

• <case_id>.jpg is the initial observation supplied to a video-generation model.
• text_prompt.txt contains the case-specific camera-motion and memory challenge instruction. It describes a continuous viewpoint change, allows physically plausible motion, and asks the rollout to preserve the input instances without adding, removing, cloning, or merging objects.
• noun_phrases.txt contains the cleaned object concepts used for reference construction.

Object reference

reference_scene.json contains the fixed input-grounded object inventory. For each instance it stores an object ID, category, bounding box, center, size and appearance attributes, an appearance embedding, the paths to its mask and crop, and mobility metadata. The mobility metadata assigns each instance to either the static_geometry or dynamic_structure evaluation track.

The associated files are:

• assets/masks/ref_*.png: instance masks aligned to the initial image;
• assets/crops/ref_*.png: object crops used for appearance evidence;
• assets/preprocessed/raw_1280x720.png: normalized processing image.

Geometry cache

reference_geometry.npz is a NumPy archive containing the precomputed input-grounded geometric evidence used by the evaluator. Depending on the case, it contains points, depth, intrinsics, valid, background_mask, one or more query_* arrays, and manifest.

The manifest array is a UTF-8 JSON document stored inside the archive. It records array integrity hashes, query IDs, schema information, and the configuration needed to interpret the geometry cache. It does not contain generated videos or evaluation results.

Loading the manifest

import json
from pathlib import Path

root = Path("OPIS-dataset")
rows = [json.loads(line) for line in (root / "metadata.jsonl").read_text().splitlines()]

row = rows[0]
image = root / row["image_path"]
case_dir = root / row["final_case_path"]
print(row["case_id"], image, case_dir)

To inspect a reference geometry archive:

import json
import numpy as np

with np.load(case_dir / "reference_geometry.npz", allow_pickle=True) as archive:
    manifest = json.loads(archive["manifest"].tobytes().decode("utf-8"))
    print(archive.files)
    print(manifest["schema_version"])

Intended evaluation protocol

For each case, a model receives the initial image and text_prompt.txt and produces a video rollout. The evaluator compares sampled generated frames with the fixed object reference derived from the initial image. Camera motion and partial occlusion are allowed; an object that is not observable is treated separately from a confirmed memory failure. The benchmark therefore evaluates observable input-instance preservation, not pixel-level imitation of a single target continuation.

The released dataset is sufficient to prepare inputs and run the reference-side evaluation pipeline. Model checkpoints, inference services, generated videos, and model-specific evaluation outputs are not included in this repository.

Citation

If you use OPIS, please cite the associated arXiv preprint:

@misc{opis2026,
  title  = {OPIS: An Input-Grounded Benchmark for Multi-Object Memory in Video World Models},
  year   = {2026},
  note   = {arXiv preprint}
}

Dataset page

Hugging Face: https://huggingface.co/datasets/Kirito-Lab/OPIS-dataset