README.md

---
license: cc-by-nc-4.0
pretty_name: FAR datasets
task_categories:
- image-to-video
tags:
- world-model
- navigation
- embodied-ai
- latent
- ai2thor
---

# FAR datasets

Pre-computed latent corpora used to train and evaluate **FAR**, a latent-diffusion
world model with a learned, action-conditioned retrieval memory, and its baselines.

- Paper: [Learning What to Recall: Adaptive Multi-Cue Episodic Memory for World Models](https://arxiv.org/abs/2609.34677)
- Code: https://github.com/sony/far
- Checkpoints: https://huggingface.co/1202kbs/FAR-Checkpoints
- Project page: https://1202kbs.github.io/FAR-Project-Page/

## Layout

Everything is stored at the path the code expects, relative to the repository root:

```
<corpus>/demo.tar, test-NNN.tar, train-NNN.tar   # tar shards; members are datasets/<corpus>/latent/<episode>/...
datasets/<corpus>/latent/latent_params.json      # how the latents were computed (VAE, scale, dtype)
results/manifests/<corpus>/*.json                # dataset manifest
results/indices/<corpus>/*.json                  # train / test (/ ctrl / event) indices
datasets.json                                    # every shard and file with size, SHA-256 and episode count
```

Shards are plain uncompressed tar files, so `tar -xf <shard> -C <repo>` puts the
episodes in place. `demo` is a subset of `test`; `test` and `train` are
disjoint. Not every corpus has a `demo` tier.

## Download

With the code checked out (fetches the shards, verifies them and extracts them once):

```bash
python scripts/download_release.py --data demo  --corpus ai2thor_v3   # the rollout-demo clips, 1.1 GB
python scripts/download_release.py --data test  --corpus ai2thor_v3   # the test split + ctrl siblings, 26 GB
python scripts/download_release.py --data train --corpus ai2thor_v3   # test + train, 84 GB
python scripts/download_release.py --data test  --corpus ai2thor_dyn  # the AI2-THOR-dyn test split, 3.1 GB
python scripts/download_release.py --data train --corpus ai2thor_dyn  # test + train, 15 GB
```

By hand:

```bash
hf download 1202kbs/FAR-Datasets-AI2THOR --repo-type dataset --local-dir /tmp/far-data \
    --include "ai2thor_v3/demo.tar" "datasets/**" "results/**" "datasets.json"
tar -xf /tmp/far-data/ai2thor_v3/demo.tar -C <repo>
cp -r /tmp/far-data/datasets /tmp/far-data/results <repo>/
```

## AI2-THOR v3

8,125 iTHOR tour episodes (256x256 RGB at 10 fps, egocentric): an exploration leg
with interaction chains at container and surface stations (open / close / pick up /
put), then a deterministic retrace whose reveals show the changed state. Test
episodes come in seed-matched pairs: an `_act` episode and a `_ctrl` sibling that
re-opens the same stations without moving anything (`moves: []`). The two test
indices are positionally aligned (`test_ctrl[i]` is the sibling of `test[i]`).

| Tier | Episodes | Shards | Size |
|---|---|---|---|
| `demo` | 228 (114 test clips + their ctrl siblings; the rollout notebook and paper figures) | `ai2thor_v3/demo.tar` | 1.1 GB |
| `test` | 2,618 (1,309 act + 1,309 ctrl) | `ai2thor_v3/test-000.tar`, `test-001.tar` | 25.9 GB |
| `train` | 5,507 | `ai2thor_v3/train-000.tar` .. `train-002.tar` | 57.6 GB |

Per episode (`datasets/ai2thor_v3/latent/<episode>/`):

| File | Shape | Contents |
|---|---|---|
| `latents.npy` | (T, 4, 32, 32) float16 | SDXL-VAE latents (`madebyollin/sdxl-vae-fp16-fix`, posterior mode, at the VAE's 0.13025 scale; see `latent_params.json`) |
| `poses.npz` | `pos` (T, 3), `quat` (T, 4), `heading`, `t`, `region` (T,) | agent pose per frame in the THOR world frame (the loader converts to the z-up convention) |
| `actions.npz` | (T,) / (T, 3) / (T, 2) | per-frame action code, `dpos`, `dyaw`, `dpitch`, interaction code, `point_uv`, `openness` |
| `legs.npz` | `leg_index`, `phase` (T,) | which tour leg / phase each frame belongs to |
| `closures.npz` | `i`, `j`, `pos_dist`, `heading_diff`, `stale` | loop-closure frame pairs (same viewpoint; `stale` = the scene changed in between) |
| `objvis.npz` | one (T,) int32 array per station object | visible pixels of each station object per frame |
| `meta.json` | | scene, seed, fps, resolution, `n_frames`, `eval_start`, stations, moves, legs, events, QC |
| `latents.change.npy` | (T, 128) uint8 | packed 32x32 latent-grid loss mask, `change` family (evaluation) |
| `latents.change_interact.npy` | (T, 128) uint8 | packed 32x32 loss mask, `change` ∪ `interact` (training) |
| `latents.keys_thor_v1.npy` | (T, 256) float32 | cached retriever keys (served through the backend's `key_suffix`) |

Loss masks were built with `scripts/data/build_masks_ai2thor.py`, the event index
with `scripts/data/build_event_index_ai2thor.py`, and the keys with
`scripts/world/build_retriever_keys.py` (see the code README to rebuild any of them).

## AI2-THOR-dyn

1,002 door-corridor episodes (256x256 RGB at 10 fps, egocentric) over 7 iTHOR
scenes, for off-screen memory of a second agent. The ego watches a doorway while
a second agent crosses it several times, alternating between the two ends of a
corridor, then walks to the doorway and looks at end A and end B. Which end the
second agent is at can only be recovered from the crossings seen earlier. Split
by seed: 800 train / 202 test episodes, every scene in both splits. There is no
`demo` tier; the whole test split is 3.1 GB.

| Tier | Episodes | Shards | Size |
|---|---|---|---|
| `test` | 202 | `ai2thor_dyn/test-000.tar` | 3.1 GB |
| `train` | 800 | `ai2thor_dyn/train-000.tar` | 11.8 GB |

Per episode (`datasets/ai2thor_dyn/latent/<episode>/`):

| File | Shape | Contents |
|---|---|---|
| `latents.npy` | (T, 4, 32, 32) float16 | SDXL-VAE latents, as for AI2-THOR v3 (see `latent_params.json`) |
| `poses.npz` | `pos` (T, 3), `quat` (T, 4), `yaw_deg`, `horizon_deg`, `heading`, `t` (T,) | ego pose per frame in the THOR world frame |
| `agent2.npz` | `x`, `z`, `px`, `state` (T,) | second-agent ground truth: floor position, on-screen pixel count, per-frame state code |
| `meta.json` | | scene, seed, number of crossings, spawn, final end, corridor ends, `eval_start`, legs, QC |
| `latents.agent.npy` | (T, 128) uint8 | packed 32x32 latent-grid mask of the second agent's silhouette (loss weighting) |
| `latents.keys_obj_v1.npy` | (T, 256) float32 | cached retriever keys used by the FAR arms |
| `latents.keys_thor_v1.npy` | (T, 256) float32 | cached retriever keys in the AI2-THOR v3 key space |

There is no `actions.npz`: the ego never acts on the world. The event index
(`ai2thor_dyn_latent_train_events.json`) holds the reveal spans used for
reveal-anchored sampling; it was built with
`scripts/data/build_event_index_ai2thor.py --spans reveal` and the masks with
`scripts/data/build_agent_masks_dyn.py`.

## License

The latents and sidecars are derived from [AI2-THOR](https://ai2thor.allenai.org/)
(Apache-2.0) renders and are released under **CC BY-NC 4.0**, like the code.

## Citation

```bibtex
@article{kim2026far,
  title   = {Learning What to Recall: Adaptive Multi-Cue Episodic Memory for World Models},
  author  = {Kim, Beomsu and Lai, Chieh-Hsin and Nguyen, Bac and Bar, Amir and Ye, Jong Chul and Mitsufuji, Yuki},
  journal = {arXiv preprint arXiv:2609.34677},
  year    = {2026},
  url     = {https://arxiv.org/abs/2609.34677}
}
```