# RememBench usage guide

[Dataset overview](../README.md)

## Download and load

```bash
pip install huggingface_hub
hf download evanbuzzZ/RememBench --repo-type dataset --local-dir RememBench
cd RememBench
pip install -r requirements.txt
```

```python
from datasets import load_dataset

t2v = load_dataset("evanbuzzZ/RememBench", "t2v", split="test")
i2v = load_dataset("evanbuzzZ/RememBench", "i2v", split="test")

sample = t2v[0]
prompts = sample["prompts"]
seed = int(sample["seed"])
```

**Seeds are decimal strings.** Some T2V seeds exceed the exact-integer range of JavaScript numbers. Convert them directly to an integer in your generation code; do not pass them through a floating-point value.

Check the downloaded data and inspect one sample:

```bash
python scripts/validate.py
python scripts/load_example.py --subset i2v --index 0
```

For reproducible experiments, pin the Hugging Face repository commit with `revision=` or `--revision`.

## T2V inputs

Each row of `data/t2v/test.jsonl` contains:

| Field | Meaning |
|---|---|
| `scene_id`, `source_index` | Stable scene identifier and original candidate index |
| `target_description` | Target content described by the prompt |
| `prompts` | Four prompts: appears, disappears, remains out of sight, reappears |
| `prompt_start_seconds` | Nominal segment starts: `[0.0, 3.6, 6.2, 11.2]` |
| `seed` | Exact noise seed, stored as a decimal string |
| `num_frames`, `fps`, `width`, `height` | Paper setting: 379 frames, 24 fps, 1376 × 768 |
| `num_chunks`, `denoising_steps_per_chunk` | Paper setting: 23 chunks, four denoising steps per chunk |

The prompt schedule specifies intended action timing, not the exact generated action frames. The five-second third segment keeps the target out of sight longer than the largest sliding-window baseline's approximately three seconds of recent context. The paper retained 100 prompts from a 466-scene candidate pool after screening an H3-AR rollout for compliance. Evaluation uses the same retained prompts and seeds across methods and budgets.

## I2V inputs and initial frames

Each row of `data/i2v/test.jsonl` contains:

| Field | Meaning |
|---|---|
| `sample_id`, `scene_id` | Unique scene–trajectory identifier and source DL3DV scene ID |
| `scene_type` | `indoor` or `outdoor` |
| `prompt` | Caption describing visible scene content without prescribing camera motion |
| `image_path` | Relative path populated by the image preparation script |
| `trajectory_path` | Relative path to a bundled NumPy archive |
| `setting`, `rotation_degrees`, `direction`, `translation` | Camera-motion setting; direction is `left` or `right` |
| `seed` | Paper generation seed, `"0"` |
| `num_frames`, `fps`, `width`, `height` | Paper setting: 253 frames, 16 fps, 832 × 480 |
| `num_chunks`, `latent_frames`, `denoising_steps_per_chunk` | 16 chunks, 64 latent frames, four denoising steps per chunk |
| `pose_samples`, `intrinsics_samples` | Lengths of the original camera arrays |

`sources/i2v_images.jsonl` contains one record per unique scene, with its upstream repository, archive path, retrieval revision, preprocessing rule, and SHA-256 of the expected RGB pixels. Initial frames are taken from the first image member in lexicographic archive-path order, center-cropped to the target aspect ratio, then resized to 832 × 480 using Lanczos.

Obtain access to [DL3DV-ALL-960P](https://huggingface.co/datasets/DL3DV/DL3DV-ALL-960P) under its own terms. If you already have the scene archives or extracted scene folders:

```bash
python scripts/prepare_i2v_images.py --source-dir /path/to/DL3DV-ALL-960P
python scripts/validate.py --require-images
```

Alternatively, retrieve the required first frames through your authorized Hugging Face account:

```bash
hf auth login
python scripts/prepare_i2v_images.py --download
```

The download option uses HTTP range requests to read the first image from each source archive, without downloading all of its video frames. Use `--limit 1` to try one scene first. Existing prepared images are validated and skipped. The script refuses a pixel-hash mismatch, rather than silently substituting a different input.

### Camera representation

Each `.npz` file has `poses` and `intrinsics`, copied without changing their numerical values from the final experiment inputs:

- `poses`: float32 camera-to-world matrices of shape `(T, 4, 4)`. Camera axes are x right, y down, z forward. The source world frame is z up; the first camera is at `[0, 0, 1.5]`, facing world +y. Translation values retain the source trajectory's depth-derived scale.
- `intrinsics`: float32 rows `[fx, fy, cx, cy]` in pixels at 832 × 480. Intrinsics are constant over each trajectory. Some source arrays have a different number of rows from `poses`; use the first intrinsics row, as in the paper's implementation.

The source pose sequence contains 256 or 257 samples, not the 253 decoded video frames. In the paper's LingBot-World-Infinity setup, rotation is interpolated with SLERP and translation linearly at 64 equally spaced positions over the full pose sequence, including both endpoints. The backbone then uses relative consecutive poses with translation normalized by the largest displacement, following its camera-conditioning implementation. Preserve the complete source sequence rather than truncating it to the decoded frame count.

For 90° and 180° rotation, the camera turns away and reverses. For 360°, it completes a continuous full turn. Translation moves into the scene and returns. All source trajectories end at their initial position and orientation.

## Evaluation

The paper uses **RAVEN-adapted MiniMax-H3 (H3-AR)** for T2V and **LingBot-World-Infinity** for I2V. Compare methods using the same prompts and noise seed; I2V methods also share the conditioning frame and input trajectory. Retrieval methods retain two recent chunks and one or two chunks of far memory. Base retains additional recent chunks to match the total active visual KV budget, with the same backbone-specific attention sink.

T2V departure and revisit frames are manually annotated. The departure frame is shared across methods within a scene; the revisit is marked separately for each generated rollout. I2V uses the conditioning frame as departure and selects each rollout's revisit from its own Pi3X reconstruction. For rotation, find the frame whose viewing direction differs most from the initial direction; for translation, find the frame farthest from the initial position. From that turnaround onward, select the frame with the smallest unsigned viewing-direction angle to the initial frame. Reconstruct all decoded frames, with inputs resized to approximately 255,000 pixels and dimensions rounded to multiples of 14.

| Metric | Definition | Aggregation |
|---|---|---|
| CLIP ↑ | Cosine similarity of L2-normalized CLIP ViT-H/14 LAION-2B embeddings of departure and revisit | Median over scenes |
| LPIPS ↓ | AlexNet, version 0.1, on native-resolution image pairs scaled to `[-1, 1]` | Median over scenes |
| TempSSIM ↑ | Grayscale SSIM over consecutive frames, 11 × 11 Gaussian window, sigma 1.5 | Mean within each video, then median over scenes |
| Drift ↓ | Cosine distance between adjacent chunks, each represented by the normalized average of CLIP embeddings from four evenly spaced frames | Mean within each video, then median over scenes |

H3-AR decodes an initial five-frame chunk followed by 17-frame chunks; LingBot-World-Infinity decodes an initial 13-frame chunk followed by 16-frame chunks. Scores use original rollouts before compression for the Video Viewer.

`evaluation/t2v_reference_pairs.jsonl` contains 600 annotations and CLIP/LPIPS measurements: 100 scenes × three methods × two comparison budgets. Frame indices are zero-based. These annotations describe the paper's specific generated rollouts; **they are not reusable ground-truth frame indices for a new model or rerun**. Original rollout videos are not included in this input package. `source_arm` identifies the original run, and `comparison_budget_chunks` identifies the matched-budget comparison; Base has no retrieved far memory.

`evaluation/t2v_reference_summary.json` reproduces the paper's median T2V CLIP and LPIPS values:

| Method | CLIP, 1 chunk | LPIPS, 1 chunk | CLIP, 2 chunks | LPIPS, 2 chunks |
|---|---:|---:|---:|---:|
| Base | 0.755 | 0.659 | 0.751 | 0.652 |
| MoC | 0.832 | 0.594 | 0.841 | 0.569 |
| MosaiChunk | 0.899 | 0.567 | 0.936 | 0.500 |

## Provenance, limitations, and licensing

`sources/input_provenance.json` records hashes of the source manifests, prompts, trajectories, seeds, and annotations used for this export. `checksums.sha256` covers the distributed release files.

Prompt compliance screening used one H3-AR rollout per candidate; success rates can differ with another model. T2V revisit annotation is manual, and I2V revisit selection depends on reconstructed poses. Report the evaluated cohort and any generation failures rather than silently changing the test set. The dataset measures revisits in the supplied scenarios and trajectories; it is not an exhaustive measure of video quality or world understanding.

Publication licensing for the RememBench-authored material is pending. DL3DV content remains subject to the [DL3DV license and Terms of Use](https://github.com/DL3DV-10K/Dataset/blob/main/License.md); this repository does not grant additional rights to it. The initial-frame pixels are obtained from the upstream source by the user and are not redistributed here. The four-stage T2V design extends the appear–disappear–reappear design of Ring Forcing; construction details and citations are in the linked paper.

Please cite the MosaiChunk paper when using RememBench and acknowledge DL3DV when using the I2V split. The paper is linked above.