README.md

---
pretty_name: OPIS Dataset
tags:
  - multimodal
  - image-to-video
  - video-generation
  - object-centric-evaluation
  - world-models
  - memory-evaluation
size_categories:
  - 1K<n<10K
configs:
  - config_name: default
    data_files:
      - split: train
        path: metadata.jsonl
---

# 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.


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).

[![Paper](https://img.shields.io/badge/arXiv-2609.35052-b31b1b.svg)](https://arxiv.org/abs/2609.35052)
[![Dataset](https://img.shields.io/badge/%F0%9F%A4%97%20Dataset-Hugging%20Face-FFD21E.svg)](https://huggingface.co/datasets/Kirito-Lab/OPIS-datase)
[![Code](https://img.shields.io/badge/Code-GitHub-181717.svg?logo=github)](https://github.com/SSStarain/OPIS)

![OPIS dataset construction pipeline](assets/fig2.png)


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

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

```json
{
  "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

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

```python
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 OPIS is useful in your research, please cite the paper:

```bibtex
@misc{wang2026opisinputgroundedbenchmarkmultiobject,
      title={OPIS: An Input-Grounded Benchmark for Multi-Object Memory in Video World Models}, 
      author={Hao Wang and Tao Yu and Liuzhou Zhang and HeXin Wang and Haopeng Jin and Yuxuan Zhou and Xinming Wang and Hongzhu Yi and Xinye Li and Yuanlei Wang and Ping Nie and Yan Huang and Yuxuan Zhang and Pengfei Zhou and Yanyan Zou and Wei Yang},
      year={2026},
      eprint={2609.35052},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2609.35052}, 
}
```