Update docs

README.md

@@ -41,48 +41,275 @@ configs:
 
 The release contains **50 event-rich Blender scenes**, structured causal event graphs, **872 graph-grounded diagnostic questions**, three levels of future-event specification, and **2,832 controlled counterfactual variants**. A subset of **225 matched factual-counterfactual pairs** supports evaluation of selective responsiveness to physical interventions.
 
-## Evaluation
+## Dataset Overview
+
+### Scene Diversity
+
+![Overview](assets/showcase/scene_overview.png)
+
+### Three Levels of Future-Event Specification
+
+The same initial frame and reference rollout are paired with three textual conditions: **state-only** (describes the current scene state and relevant physical conditions), **trigger-aware** (additionally specifies the initiating event), and **full event-chain** (verbalizes the major event chain). 
+
+<details>
+<summary>View example: Y-shaped domino cascade</summary>
+
+![Case preview](assets/showcase/reference_cascade.gif)
+
+<details>
+<summary>Show the three prompt levels</summary>
+
+**Level 1: State-only**
+
+```text
+Generate a physically realistic continuation video by predicting the subsequent physical evolution from the given fixed-camera first frame.
+
+Important instructions:
+- Preserve the fixed camera view.
+- The first frame is authoritative for all visible geometry, object sizes, initial poses, contact relations, spatial layout, and camera view.
+- Treat only the listed dynamic active objects and dynamic active object groups as freely moving rigid bodies.
+- Treat anchored static colliders as fixed to the world.
+
+Global rigid-body convention:
+- All rigid bodies use friction = 0.50, restitution = 0.10, linear damping = 0.04, angular damping = 0.10.
+- For every rigid body, the geometric center is also its center of mass.
+
+Dynamic active objects:
+- upper branch target sphere: the large target sphere at the upper/right end of the fork. Mass = 1.0 kg.
+- lower branch target sphere: the large target sphere at the lower/right end of the fork. Mass = 1.0 kg.
+
+Dynamic active object groups:
+- central stem domino row: the five upright dominoes forming the straight stem before the fork splits. This group contains 5 dominoes. Each object has mass = 1.0 kg.
+- upper fork domino branch: the upper row of upright dominoes after the split. This group contains 9 dominoes. Each object has mass = 1.0 kg.
+- lower fork domino branch: the lower row of upright dominoes after the split. This group contains 9 dominoes. Each object has mass = 1.0 kg.
+
+Anchored static objects:
+- wooden tabletop surface: the broad surface beneath the forked domino structure.
+
+Decorative context:
+- The remaining objects are anchored static decorators and should remain visually unchanged.
+```
+
+**Level 2: Trigger-aware**
+
+```text
+Generate a physically realistic continuation video by predicting the subsequent physical evolution from the given fixed-camera first frame.
+
+Trigger event: The first tilted blue domino at the left start of the fork falls into the next domino.
+
+Important instructions:
+- Preserve the fixed camera view.
+- The first frame is authoritative for all visible geometry, object sizes, initial poses, contact relations, spatial layout, and camera view.
+- Treat only the listed dynamic active objects and dynamic active object groups as freely moving rigid bodies.
+- Treat anchored static colliders as fixed to the world.
+
+Global rigid-body convention:
+- All rigid bodies use friction = 0.50, restitution = 0.10, linear damping = 0.04, angular damping = 0.10.
+- For every rigid body, the geometric center is also its center of mass.
+
+Dynamic active objects:
+- upper branch target sphere: the large target sphere at the upper/right end of the fork. Mass = 1.0 kg.
+- lower branch target sphere: the large target sphere at the lower/right end of the fork. Mass = 1.0 kg.
+
+Dynamic active object groups:
+- central stem domino row: the five upright dominoes forming the straight stem before the fork splits. This group contains 5 dominoes. Each object has mass = 1.0 kg.
+- upper fork domino branch: the upper row of upright dominoes after the split. This group contains 9 dominoes. Each object has mass = 1.0 kg.
+- lower fork domino branch: the lower row of upright dominoes after the split. This group contains 9 dominoes. Each object has mass = 1.0 kg.
+
+Anchored static objects:
+- wooden tabletop surface: the broad surface beneath the forked domino structure.
+
+Decorative context:
+- The remaining objects are anchored static decorators and should remain visually unchanged.
+```
+
+**Level 3: Full event-chain**
+
+```text
+A curved, slightly branching line of brightly colored domino blocks stands upright across the middle of a wooden tabletop, with a small purple cone at the far left, a small red-and-teal rounded piece behind the dominoes, several little green and brown peg-like toys in front, a large pink ball near the back-right end, and a large light-blue ball near the front-right end. The motion starts at the left end when the first domino tips and hits the next, launching a chain reaction that travels steadily from left to right through the whole arrangement. Each block knocks its neighbor over, and the collapse passes through the center and then fans through the angled right-side branches, so the dominoes slap down in sequence and spread into overlapping lines on the table. As the final rightmost blocks fall, they nudge the two large balls, making the pink ball roll slightly farther back and right and the blue ball roll rightward away from the domino pile. By the end, all of the dominoes lie flat in a scattered fan-shaped heap across the center, the two balls have shifted to the right, and the smaller cone and peg-like pieces remain standing around the wreckage. Keep the camera fixed.
+```
+
+</details>
+
+</details>
+
+### Factual–Counterfactual Pairs
+
+Each edit applies a single-object **delete**, **move**, **scale**, or **mass** intervention and provides separately simulated factual and counterfactual references with matched Level 1 prompts.
+
+<details>
+<summary>View delete intervention case</summary>
+
+![Fig3_Delete](assets/showcase/delete_pair.gif)
+
+**Description:** Remove the third peg from the left in the top row of the Galton board.
+
+</details>
+
+<details>
+<summary>View move intervention case</summary>
+
+![Fig4_Move](assets/showcase/move_pair.gif)
+
+**Description:** Move the first pink domino on the upper branch of the Y-shaped chain toward the upper left.
+
+</details>
+
+<details>
+<summary>View scale intervention case</summary>
+
+![Fig5_Scale](assets/showcase/scale_pair.gif)
 
-The benchmark supports factual causal-cascade evaluation under three levels of future-event specification and paired counterfactual evaluation under *delete*, *move*, scale, and mass interventions. Motion-based metrics and graph-grounded diagnostic VQA provide complementary measures of physical evolution and causal-process fidelity.
+**Description:** Reduce the height of the rightmost yellow domino on the middle step.
 
-See [the evaluation protocol](docs/EVALUATION.md) for prompt conditions, metrics, and scoring.
+</details>
 
-## Load metadata
+<details>
+<summary>View mass intervention case</summary>
+
+![Fig6_Mass](assets/showcase/mass_pair.gif)
+
+**Description:** Increase the mass of the barrel.
+
+</details>
+
+## Results
+
+### Causal Cascade Fidelity
+
+![RQ1Result](assets/showcase/causal_fidelity.png)
+
+**Left**: Performance of current I2V models under the Level 1 prompt.
+**Right**: Model-average performance as future-event specification becomes more explicit.
+
+### Selective Causal Responsiveness
+
+![RQ2Result](assets/showcase/counterfactual_response.png)
+
+**Counterfactual motion response across intervention types. Each marker denotes one I2V model.** Higher values on both axes indicate stronger selective causal responsiveness.
+
+For evaluation code and further usage, see the [GitHub repository](https://github.com/SJTU-DeepDeltaLab/CausalCascade).
+
+## Choose a Configuration
+
+| Configuration | Rows | Use it to access |
+|---|---:|---|
+| `base_scenes` | 50 | Initial frames, reference videos, three prompt levels, event graphs, QA, and scene metadata. |
+| `counterfactuals` | 2,832 | All retained single-object edits, targets, instructions, and JSON deltas. Media paths are populated only for the 225 RQ2 variants. |
+| `rq2_pairs` | 225 | Ready-matched factual/counterfactual frames, videos, Level 1 prompts, and edit deltas: 50 delete, 50 move, 50 scale, 75 mass. |
+| `diagnostic_qa` | 872 | Individual questions, answer options, reference answers, and graph references across five diagnostic dimensions. |
+
+All configurations use one public benchmark split, `test`. Notice that only the 225 RQ2 variants have edited initial frames and reference videos in this release. Other variants provide edit metadata, which can be used to produce counterfactual media.
+
+### Read Metadata
+
+```bash
+pip install "datasets>=4,<5"
+```
 
 ```python
 from datasets import load_dataset
 
 repo = "deepdeltalab/CausalCascade"
-base = load_dataset(repo, "base_scenes", split="test")
-counterfactuals = load_dataset(repo, "counterfactuals", split="test")
-rq2 = load_dataset(repo, "rq2_pairs", split="test")
-qa = load_dataset(repo, "diagnostic_qa", split="test")
+base_table = load_dataset(repo, "base_scenes", split="test")
+pairs_table = load_dataset(repo, "rq2_pairs", split="test")
+edits_table = load_dataset(repo, "counterfactuals", split="test")
+qa_table = load_dataset(repo, "diagnostic_qa", split="test")
+print(len(base_table), len(pairs_table), len(edits_table), len(qa_table))
+# 50 225 2832 872
+
+# Select metadata columns before accessing rows to avoid native video decoding.
+row = base_table.select_columns(["scene_id", "reference_video_path"])[0]
+print(row)
+```
+
+The Hub viewer displays images/videos for `base_scenes` and `rq2_pairs`. The separate `*_path` fields are repository-relative strings. Use the loader below to fetch and decode the assets without manually matching files.
+
+## Load Media and Annotations
+
+Use Python 3.10+. Download just the loader files, then install locally; this does not download the dataset's videos or Blender files:
+
+```bash
+pip install -U huggingface_hub
+hf download deepdeltalab/CausalCascade --repo-type=dataset --include="causalcascade/*.py" --include="pyproject.toml" --local-dir=CausalCascade-loader
+pip install -e "./CausalCascade-loader[video]"
 ```
 
-The `base_scenes` and `rq2_pairs` viewers display native image and video
-columns; `counterfactuals` displays counterfactual-variant metadata. Original `*_path`
-columns remain repository-relative paths. Use the included `causalcascade`
-wrapper to resolve and decode media lazily:
+The bundled loader resolves assets on access and caches Hub downloads. It uses OpenCV for videos; native `datasets.Video` decoding and TorchCodec are not required for this route.
+
+### One Base Scene
 
 ```python
-from torch.utils.data import DataLoader
-from causalcascade import CausalCascadeDataset, collate_fn
+from causalcascade import CausalCascadeDataset
+
+base = CausalCascadeDataset(
+    repo_id="deepdeltalab/CausalCascade",
+    subset="base_scenes",
+    decode_video=False,
+)
+sample = base[0]
+print(sample["scene_id"])
+print(sample["initial_frame"].shape)  # RGB uint8: (3, H, W)
+print(sample["prompt_level1"])       # State-only
+# prompt_level2: trigger-aware; prompt_level3: full event-chain
+print(len(sample["event_graph"]["events"]))
+print(len(sample["event_graph"]["causal_edges"]))
+
+question = sample["diagnostic_qa"]["questions"][0]
+print(question["question"])
+print(question["answer_options"], question["ground_truth_answer"])
+# sample["scene_metadata"] contains the Blender-derived metadata.
+```
+
+With `decode_video=False`, `reference_video_path` remains a relative string and no video is downloaded. Set `decode_video=True` to also obtain `sample["reference_video"]`.
+
+### One Factual–Counterfactual Pair
+
+```python
+from causalcascade import CausalCascadeDataset
 
-dataset = CausalCascadeDataset(
-    repo_id=repo,
+pairs = CausalCascadeDataset(
+    repo_id="deepdeltalab/CausalCascade",
     subset="rq2_pairs",
-    decode_images=True,
     decode_video=True,
-    video_size=(480, 854),
-    video_frame_stride=2,
+    video_size=(240, 426),    # Preview size: (height, width)
+    video_frame_stride=4,
+    video_max_frames=16,     # At most 16 sampled frames per video
 )
-loader = DataLoader(dataset, batch_size=1, num_workers=4, collate_fn=collate_fn)
+pair = pairs[0]
+print(pair["scene_id"], pair["variant_id"], pair["edit_type"])
+print(pair["factual_initial_frame"].shape)
+print(pair["counterfactual_initial_frame"].shape)
+print(pair["factual_reference_video"].shape)         # (T, 3, 240, 426)
+print(pair["counterfactual_reference_video"].shape)
+print(pair["factual_prompt_level1"])
+print(pair["counterfactual_prompt_level1"])
+print(pair["delta"])                                # Parsed intervention JSON
+```
+
+Use the two supplied Level 1 prompts as generation condition.`rq2_pairs` provides matched media, prompts, and deltas; base graphs/QA are accessed through `base_scenes` using the same `scene_id`. Counterfactual graphs/QA are not part of these four tables.
+
+### PyTorch DataLoader
+
+Continuing with `pairs` above:
+
+```python
+from torch.utils.data import DataLoader
+from causalcascade import collate_fn
+
+loader = DataLoader(pairs, batch_size=1, num_workers=0, collate_fn=collate_fn)
 batch = next(iter(loader))
+print(batch["factual_reference_video"].shape)  # (1, T, 3, H, W)
+print(batch["scene_id"])                     # List of scene IDs
 ```
 
-Install the wrapper from a clone of this repository with `pip install -e ".[video]"`. See [docs/LOADING.md](docs/LOADING.md), [docs/SCHEMA.md](docs/SCHEMA.md), and [docs/EVALUATION.md](docs/EVALUATION.md).
+Images/videos are RGB `uint8` tensors in `C x H x W` / `T x C x H x W` order, with values 0–255. Equal-shaped tensors are stacked; unequal shapes remain lists. Start with `num_workers=0`, especially in Windows/notebooks. See [the loading guide](docs/LOADING.md) for batching, local/offline use, raw file downloads, filtering edits, and joining annotations; see [the schema](docs/SCHEMA.md) for all fields.
+
+## Evaluation
+
+Generate factual rollouts under state-only (L1), trigger-aware (L2), or full event-chain (L3) future-event specification. For counterfactual evaluation, use both sides of the 225 official pairs with their matched Level 1 prompts. Event graphs describe observable events and direct causal dependencies; diagnostic questions assess five complementary dimensions.
 
-Only the 225 official RQ2 variants include a rendered counterfactual initial frame and reference rollout in this release. The remaining variants provide reproducible metadata deltas but no counterfactual media. Retained variants include changes to downstream event structure as well as finer-grained motion or timing changes.
+See [the evaluation protocol](docs/EVALUATION.md) for metrics and aggregation, and the [GitHub usage guide](https://github.com/SJTU-DeepDeltaLab/CausalCascade/blob/main/USAGE.md) for runnable evaluation commands. 
 
 ## License
 

docs/EVALUATION.md

@@ -1,5 +1,7 @@
 # Evaluation protocol
 
+For loading reference samples, see the [README](../README.md) and [loading guide](LOADING.md). This document defines the evaluation protocol; runnable generation and scoring commands are in the [GitHub usage guide](https://github.com/SJTU-DeepDeltaLab/CausalCascade/blob/main/USAGE.md).
+
 ## RQ1: causal cascade fidelity
 
 Use `base_scenes` for all 50 factual initial frames and reference rollouts. Generate the complete physical process from the initial frame and one textual condition; the target is a coherent causal cascade, not only an isolated event or final outcome.

docs/LOADING.md

@@ -1,67 +1,168 @@
-# Loading
+# Loading Guide
 
-## Hugging Face metadata
+Start with the [README](../README.md#load-media-and-annotations) for loader installation and single-scene/pair examples. This guide covers metadata-only access, raw files, annotations, and batching. All examples use the public `test` split.
+
+## What Gets Loaded
+
+| Route | Behavior |
+|---|---|
+| `load_dataset()` | Loads the Parquet table. Native image/video columns may decode on row access; `*_path` strings are not automatically resolved. |
+| `CausalCascadeDataset` | Loads the table, removes native viewer columns, then resolves requested files inside `__getitem__`. |
+| `hf_hub_download()` | Downloads one named repository file and returns its local cached filename. |
+
+The wrapper fetches whole MP4 files before decoding; it does not stream video frames over HTTP. Files are cached, so repeated access normally reuses the local download. Images embedded in the Parquet viewer columns are still part of the initial table download.
+
+With the wrapper, images decode by default, videos do not, and JSON annotations load by default. Set `decode_images=False`, `decode_video=False`, and `load_annotations=False` for metadata-only samples. Disabling video decoding leaves the relative `*_path` fields; it does not produce a new local video path.
+
+## Filter and Join Metadata
+
+### Select Edits
 
 ```python
 from datasets import load_dataset
 
 repo = "deepdeltalab/CausalCascade"
-rq2 = load_dataset(repo, "rq2_pairs", split="test")
-print(rq2.select_columns("counterfactual_reference_video_path")[0])
+edits = load_dataset(repo, "counterfactuals", split="test")
+move_edits = edits.filter(lambda row: row["edit_type"] == "move")
+official = edits.filter(lambda row: row["in_rq2_subset"])
+assert len(official) == 225
+row = move_edits[0]
+print(row["variant_id"], row["target_object_id"], row["edit_instruction"])
+print(row["counterfactual_reference_video_path"])  # None outside RQ2
 ```
 
-The `base_scenes` and `rq2_pairs` viewers display native `Image` and `Video`
-columns. The `counterfactuals` viewer contains metadata and media paths.
-Image bytes are
-embedded in Parquet; video columns reference MP4 files in this repository
-using `hf://datasets/deepdeltalab/CausalCascade@main/` URIs.
-The separate `*_path` columns remain repository-relative strings.
+`counterfactuals` has no native media preview columns, so filtering its metadata does not invoke a video decoder. Filter on `edit_type` values `delete`, `move`, `scale`, or `mass`; variant IDs use directory prefixes such as `move_type/`.
 
-To inspect metadata without decoding native media:
+### Get Questions for a Scene
 
 ```python
-rq2_metadata = rq2.remove_columns([
-    "factual_initial_frame", "counterfactual_initial_frame",
-    "factual_reference_video", "counterfactual_reference_video",
-])
+from datasets import load_dataset
+
+repo = "deepdeltalab/CausalCascade"
+scene_id = "Domino_Series/ball_trigger_step_domino_chain"
+questions = load_dataset(repo, "diagnostic_qa", split="test")
+scene_questions = questions.filter(lambda row: row["scene_id"] == scene_id)
+q = scene_questions[0]
+print((q["scene_id"], q["question_id"]))
+print(q["dimension"], q["question"])
+print(q["answer_options"], q["reference_answer"])
+print(q["related_event_ids"], q["related_edge_ids"])
 ```
 
-Native video decoding through `datasets` requires its compatible TorchCodec
-dependencies. The wrapper below uses OpenCV and removes the viewer columns
-before reading rows, so it retains its existing lazy-loading behavior.
+Use `(scene_id, question_id)` as the unique key; question IDs can repeat across scenes. These are reference-video answers, not predictions for model-generated videos. Raw QA JSON uses `ground_truth_answer` and `source_event_ids` / `source_edge_ids`; the flattened table uses `reference_answer` and `related_event_ids` / `related_edge_ids`.
 
-## Lazy PyTorch loading
+### Attach Base Graph/QA to a Pair
 
-Clone the dataset repository and install its lightweight wrapper:
+```python
+from causalcascade import CausalCascadeDataset
 
-```bash
-pip install -e ".[video]"
+repo = "deepdeltalab/CausalCascade"
+base = CausalCascadeDataset(
+    repo_id=repo, subset="base_scenes", decode_images=False, decode_video=False,
+)
+pairs = CausalCascadeDataset(
+    repo_id=repo, subset="rq2_pairs", decode_images=False, decode_video=False,
+)
+index = {scene: i for i, scene in enumerate(base.table["scene_id"])}
+pair = pairs[0]
+factual = base[index[pair["scene_id"]]]
+graph = factual["event_graph"]
+qa = factual["diagnostic_qa"]["questions"]
+delta = pair["delta"]
+print(pair["variant_id"], len(graph["events"]), len(qa))
 ```
 
+Graphs describe observable events and direct causal dependencies, with temporal stages on nodes. The pair's `delta` describes the intervention. This join gives the **factual** graph and QA; it does not construct counterfactual graphs or answers.
+
+## Download Raw Assets Without the Wrapper
+
+To get an actual local filename, resolve a `*_path` with `hf_hub_download`. This works for PNG, MP4, JSON, prompt text, and Blender files:
+
+```python
+import json
+from datasets import load_dataset
+from huggingface_hub import hf_hub_download
+
+repo = "deepdeltalab/CausalCascade"
+base = load_dataset(repo, "base_scenes", split="test").select_columns([
+    "scene_id", "initial_frame_path", "reference_video_path", "event_graph_path",
+])
+row = base[0]  # No native viewer columns remain, so no TorchCodec is needed.
+
+def fetch(path):
+    return hf_hub_download(repo_id=repo, repo_type="dataset", filename=path)
+
+image_path = fetch(row["initial_frame_path"])
+video_path = fetch(row["reference_video_path"])
+graph_path = fetch(row["event_graph_path"])
+with open(graph_path, encoding="utf-8-sig") as stream:
+    graph = json.load(stream)
+print(image_path, video_path, len(graph["events"]))
+```
+
+Native `datasets.Video` decoding needs compatible TorchCodec dependencies. For metadata, select columns before indexing/filtering rows. For decoded video tensors without TorchCodec, use the OpenCV wrapper.
+
+## Tensor Format and Batching
+
+The loader returns the original table fields plus requested decoded media/annotations:
+
+| Output | Format |
+|---|---|
+| `initial_frame` or factual/counterfactual equivalents | RGB `torch.uint8`, `(3, H, W)`, values 0–255. |
+| `reference_video` or factual/counterfactual equivalents | RGB `torch.uint8`, `(T, 3, H, W)`. |
+| `event_graph`, `diagnostic_qa`, `scene_metadata` | Parsed per-scene JSON dictionaries for `base_scenes`. |
+| `delta` | Parsed edit JSON for `counterfactuals` and `rq2_pairs`. |
+| `*_path` | Original repository-relative strings, retained after decoding. |
+
+No float conversion or normalization is applied. If a model expects floats in `[0, 1]`, convert explicitly: `video.float() / 255`.
+
 ```python
 from torch.utils.data import DataLoader
 from causalcascade import CausalCascadeDataset, collate_fn
 
+def main():
+    dataset = CausalCascadeDataset(
+        repo_id="deepdeltalab/CausalCascade", subset="rq2_pairs",
+        decode_video=True, video_size=(240, 426),
+        video_frame_stride=4, video_max_frames=16,
+        load_annotations=False,
+    )
+    loader = DataLoader(dataset, batch_size=2, num_workers=0, collate_fn=collate_fn)
+    batch = next(iter(loader))
+    print(batch["scene_id"])
+    video = batch["factual_reference_video"]
+    print(video.shape if hasattr(video, "shape") else [v.shape for v in video])
+
+if __name__ == "__main__":
+    main()
+```
+
+`collate_fn` recursively batches dictionaries. Equal-shaped tensors stack into `(B, ...)`; unequal-shaped tensors and string/list values remain lists. JSON dictionaries are recursively collated, not kept as a list of original dictionaries; inspect annotations per sample if you need their unbatched structure.
+
+`video_size=(height, width)` applies only to videos, not initial images. `video_frame_stride` samples every nth frame; `video_max_frames` caps the number of retained frames. These controls are for inspection or downstream loading, **not official scoring**. Start with `num_workers=0`; when increasing workers in a Windows Python script, retain the `if __name__ == "__main__"` guard.
+
+## Local Data and Reproducibility
+
+For a downloaded HF-format repository containing the tables and referenced files:
+
+```python
+from causalcascade import CausalCascadeDataset
+
 dataset = CausalCascadeDataset(
-    repo_id="deepdeltalab/CausalCascade",
-    subset="rq2_pairs",
-    split="test",
-    decode_images=True,
-    decode_video=True,
-    video_size=(480, 854),  # (height, width)
-    video_frame_stride=2,
-    load_annotations=True,
+    local_root="/path/to/CausalCascade", subset="base_scenes", decode_video=True,
 )
-
-loader = DataLoader(dataset, batch_size=1, num_workers=4, collate_fn=collate_fn)
-for batch in loader:
-    factual_video = batch["factual_reference_video"]
-    counterfactual_video = batch["counterfactual_reference_video"]
-    break
+sample = dataset[0]
 ```
 
-Videos are decoded only inside `__getitem__`. `video_size`, `video_frame_stride`, and `video_max_frames` control memory use without changing the stored reference videos. Because videos may have different lengths, `collate_fn` stacks equal-shaped tensors and otherwise returns a list. Set `decode_video=False` to keep path strings without downloading videos.
+Provide exactly one of `local_root` or `repo_id`. A loader-only installation is not a local dataset checkout: it lacks `tables/` and media. Local loading preserves the Parquet feature schema while bypassing remote file resolution.
 
-The example's resizing and frame stride are loading conveniences, not the evaluation protocol. Use the complete stored rollouts and the companion metric code for official motion evaluation. For RQ2, use the matched Level 1 prompts and both factual/counterfactual references in each row; an edit instruction describes the intervention and is not a replacement generation prompt.
+For reproducible Hub loading, pass the dataset commit hash as `revision` and optionally set `cache_dir`. This fixes which table and asset versions are downloaded:
+
+```python
+dataset = CausalCascadeDataset(
+    repo_id="deepdeltalab/CausalCascade", subset="base_scenes",
+    revision="<dataset-commit-hash>", cache_dir="./hf-cache",
+)
+```
 
-For a local checkout, replace `repo_id` with `local_root="/path/to/CausalCascade"`.
+For official evaluation, use complete stored MP4s and the companion metric scripts; preview sampling is not the benchmark protocol. See [Evaluation](EVALUATION.md) and the [GitHub usage guide](https://github.com/SJTU-DeepDeltaLab/CausalCascade/blob/main/USAGE.md).

docs/SCHEMA.md

@@ -23,7 +23,9 @@ in the Hub viewer without duplicating video bytes in Parquet.
 | `scene_metadata_path` | string | Blender-derived scene metadata. |
 | `prompt_level1`, `prompt_level2`, `prompt_level3` | string | State-only, trigger-aware, and full event-chain future-event specification. |
 | `num_rigid_bodies` | int | Objects with rigid-body metadata. |
+| `num_objects` | int | Total objects recorded in the scene metadata. |
 | `num_events`, `num_causal_edges`, `temporal_depth` | int | Event-graph statistics. |
+| `blender_file_path` | string | Source Blender scene, downloadable separately from media. |
 
 Event graph edges represent direct causal dependencies, not mere temporal precedence. Relative timing is recorded by node temporal stages. The prompt levels vary future-event specification; they need not be literal extensions of one another.
 
@@ -51,6 +53,19 @@ Each row joins one base scene to one selected counterfactual variant. The model-
 
 The `factual_prompt_level1` and `counterfactual_prompt_level1` fields provide matched Level 1 conditions, with only intervention-affected attributes updated. Factual and counterfactual reference videos come from separate simulations, not manual video edits.
 
+| Field | Description |
+|---|---|
+| `pair_id`, `scene_id`, `variant_id`, `edit_type` | Pair identity, base-scene join key, variant identity, and intervention type. |
+| `factual_initial_frame_path`, `counterfactual_initial_frame_path` | Repository-relative PNG paths. |
+| `factual_reference_video_path`, `counterfactual_reference_video_path` | Repository-relative MP4 paths. |
+| `factual_prompt_level1`, `counterfactual_prompt_level1` | Full generation prompts for the two initial states. |
+| `counterfactual_prompt_path` | Raw counterfactual prompt text file. |
+| `delta_json_path` | Raw intervention JSON. |
+
+The loader adds decoded media fields without the `_path` suffix when requested, and parses `delta_json_path` into `delta`. It does not attach a base graph or QA to pair rows automatically: join `base_scenes` on `scene_id`. Counterfactual event graphs and QA are not supplied in these configurations.
+
 ## `diagnostic_qa` (872 rows)
 
 Each row contains a closed-ended diagnostic question, its reference answer, and native list-valued `related_event_ids` and `related_edge_ids`. These references are validated against the corresponding event graph. The five dimensions are event occurrence, causal pathway, temporal ordering, outcome and termination, and scene consistency. Questions are traceable to events, dependencies, temporal stages, or participants; this table is not a set of human verdicts on model-generated videos.
+
+Use `(scene_id, question_id)` as the unique question key; `question_id` alone can repeat across scenes. The flattened table uses `reference_answer`, `dimension`, and `related_event_ids` / `related_edge_ids`. Raw per-scene QA JSON uses `ground_truth_answer`, `diagnostic_dimension`, and `source_event_ids` / `source_edge_ids` for the same information. The loader preserves the raw JSON schema under `diagnostic_qa`.