Use main-paper figures and document sharded release

README.md

@@ -22,11 +22,11 @@ size_categories:
 
 **Deeply Interleaved Text-Image Contexts for Multimodal LLMs Assessment**
 
-TIC-Bench is a multimodal question-answering benchmark for evaluating whether multimodal large language models can bind, integrate, and propagate evidence across long, deeply interleaved sequences of images and text. It covers three complementary association domains and eight reasoning types.
+TIC-Bench evaluates whether multimodal large language models can bind, integrate, and propagate evidence across long, deeply interleaved sequences of images and text. It contains 2,280 unique questions covering spatial, logical, and temporal association reasoning.
 
 [Main paper](paper/TIC-Bench.pdf) · [Technical supplementary material](paper/TIC-Bench-Supplementary.pdf)
 
-![TIC-Bench dataset construction pipeline](assets/dataset_construction_pipeline.png)
+![Figure 1 from the main paper: TIC-Bench overview](assets/main_figure_1_overview.png)
 
 ## Benchmark composition
 
@@ -47,112 +47,104 @@ The paper defines a benchmark of **2,280 questions** and **45,776 image instance
 | **Spatial subtotal** |  | **770** |
 | **Total** |  | **2,280** |
 
-## Domains
+![Figure 2 from the main paper: examples from all three benchmark domains](assets/main_figure_2_benchmark.png)
 
-### Logical Association
+## Tasks
 
-Logical instances connect visual scenes through shared objects and textual relations. A model must ground indirect textual references in the corresponding images and follow the target object through a linear chain, a chain that revisits a previous scene, or multiple branches that converge on a shared answer.
+- **Spatial Association** combines overlapping local crops and substituted text clues to infer relative directions. It contains aerial maps and natural photographs.
+- **Logical Association** follows shared objects and textual relations through linear, cyclic, or convergent visual structures.
+- **Temporal Association** follows identities and events through sequential, retrospective, or parallel story structures.
 
-![Convergent logical reasoning example](assets/logical_convergent_example.png)
+![Figure 3 from the main paper: logical and temporal task structures](assets/main_figure_3_tasks.png)
 
-### Temporal Association
+## Download-oriented release format
 
-Temporal instances combine identity images, ordered storyboard frames, and interleaved event descriptions. Questions test whether a model can follow later developments, retrieve evidence from earlier scenes, or integrate concurrent storylines.
+The dataset is distributed as **15 uncompressed tar shards** rather than more than 23,000 individually downloaded files. Every `question_*` folder remains intact inside one shard, so its QA file and referenced images are always downloaded together. The whole release is approximately 19 GiB, and each domain can be downloaded independently.
 
-![Parallel temporal reasoning example](assets/temporal_parallel_example.png)
-
-### Spatial Association
-
-Spatial instances divide a north-up source image into overlapping local crops. Selected crops are replaced with local textual descriptions and spatial-continuity clues. A model must combine the remaining images and substituted text to infer the relative direction of two targets. The domain contains aerial map scenes and natural photographs.
-
-![Map-based spatial reasoning example](assets/spatial_map_example.png)
+```text
+data/
+├── ticbench-spatial-00000-of-00001.tar
+├── ticbench-logical-00000-of-00010.tar ... 00009-of-00010.tar
+├── ticbench-temporal-00000-of-00004.tar ... 00003-of-00004.tar
+├── manifest.jsonl
+├── dataset_index.json
+├── SHA256SUMS
+└── metadata/
+paper/
+assets/
+ticbench_loader.py
+```
 
-## Repository structure
+The paths stored inside the shards preserve the original domain layout:
 
 ```text
-.
-├── spatial_qa_shuffled/
-│   ├── final_qids_balanced.json
-│   └── question_*/
-│       ├── dataset_caption.jsonl
-│       └── referenced images
-├── visual_construct_final/
-│   ├── extended_excluded_qids.json
-│   └── question_*/
-│       ├── qa_pairs_*.json
-│       └── referenced images
-├── time_qa/
-│   ├── excluded_qids_final.json
-│   └── question_*/
-│       ├── qa_pairs*.json
-│       └── identity and scene images
-├── migration_report.json
-├── assets/
-└── paper/
+spatial_qa_shuffled/question_*/dataset_caption.jsonl
+visual_construct_final/question_*/qa_pairs_*.json
+time_qa/question_*/qa_pairs*.json
 ```
 
-The distributed `question_*` folders are already filtered to the intended benchmark selection. The root selection JSON files are retained for provenance and auditability.
+`manifest.jsonl` provides one row per QA record with its QID, domain, paper-facing task type, question folder, QA filename, record index, and shard. `dataset_index.json` summarizes record counts, duplicate-QID diagnostics, shard sizes, and SHA-256 hashes. `SHA256SUMS` supports independent integrity checks.
 
-## Data formats
+## Quick start
 
-### Spatial QA
+Install the Hub client and download only the domain you need:
 
-The canonical file is `dataset_caption.jsonl`. Each line is one question and includes a globally unique `qid`, an interleaved `sequence`, the reference `answer`, choices, and crop/detection metadata. Inference should use `dataset_caption.jsonl`, not the earlier intermediate `dataset.jsonl` format.
-
-### Logical QA
+```bash
+pip install -U huggingface_hub
+```
 
-Each `qa_pairs_*.json` file contains a `qa_pairs` array. A question record includes the natural-language question, answer, reasoning depth, graph type, `qid`, and review/filtering fields.
+```python
+from huggingface_hub import snapshot_download
+
+local_repo = snapshot_download(
+    repo_id="pino10010/DataConstruct",
+    repo_type="dataset",
+    allow_patterns=[
+        "data/manifest.jsonl",
+        "data/dataset_index.json",
+        "data/ticbench-spatial-*.tar",  # change to logical or temporal
+        "ticbench_loader.py",
+    ],
+)
+print(local_repo)
+```
 
-The stored graph labels map to the paper terminology as follows:
+Use the included helper to inspect the manifest and safely extract a domain:
 
-| Stored label family | Paper terminology |
-|---|---|
-| `linear`, `star` | Linear |
-| `loop` | Cyclic |
-| `branch_merge`, `branch merge`, `cross` | Convergent |
+```python
+import sys
+from pathlib import Path
 
-### Temporal QA
+sys.path.insert(0, local_repo)
+from ticbench_loader import iter_manifest, extract_domain
 
-Each `qa_pairs*.json` file contains a story `description` and a `qa` array. Records include the question, reference answer, reasoning steps, task type, `qid`, and review fields.
+root = Path(local_repo)
+spatial_rows = list(iter_manifest(root, domain="spatial"))
+print(len(spatial_rows), spatial_rows[0])
 
-| Stored label | Paper terminology |
-|---|---|
-| `Linear` | Sequential |
-| `Loop` | Retrospective |
-| `Branch` | Parallel |
+extract_domain(root, domain="spatial", output_dir="./ticbench-spatial")
+```
 
-## Minimal loading example
+You can also locate one QID before downloading or extracting unrelated shards:
 
 ```python
-import json
-from pathlib import Path
+from ticbench_loader import find_qid
 
-root = Path(".")
-
-# Spatial: JSONL, one QA per line
-spatial = []
-for path in root.glob("spatial_qa_shuffled/question_*/dataset_caption.jsonl"):
-    with path.open(encoding="utf-8") as stream:
-        spatial.extend(json.loads(line) for line in stream if line.strip())
+for row in find_qid(root, "qid_20260606_235445_0001"):
+    print(row["shard"], row["question_folder"], row["qa_file"])
+```
 
-# Logical: JSON object containing a qa_pairs list
-logical = []
-for path in root.glob("visual_construct_final/question_*/qa_pairs_*.json"):
-    with path.open(encoding="utf-8") as stream:
-        logical.extend(json.load(stream).get("qa_pairs", []))
+## QA formats
 
-# Temporal: JSON object containing a qa list
-temporal = []
-for path in root.glob("time_qa/question_*/qa_pairs*.json"):
-    with path.open(encoding="utf-8") as stream:
-        temporal.extend(json.load(stream).get("qa", []))
+- **Spatial:** `dataset_caption.jsonl`; each line is a QA record with an interleaved `sequence`, reference answer, choices, and metadata. Use this final caption format rather than the earlier `dataset.jsonl` intermediate format.
+- **Logical:** `qa_pairs_*.json`; the `qa_pairs` array contains question, answer, reasoning depth, graph type, QID, and review/filtering fields.
+- **Temporal:** `qa_pairs*.json`; the `qa` array contains question, reference answer, reasoning steps, task type, QID, and review fields, alongside the story description.
 
-print(len(spatial), len(logical), len(temporal))
-```
+Stored logical labels `linear`/`star`, `loop`, and `branch_merge`/`cross` correspond to Linear, Cyclic, and Convergent. Stored temporal labels `Linear`, `Loop`, and `Branch` correspond to Sequential, Retrospective, and Parallel.
 
 ## Data integrity note
 
-The release directory contains 2,280 unique QIDs. In the current Temporal source files, four QIDs are each attached to two different QA records, so a naive row count returns 730 Temporal records instead of the paper's 726 unique-QID instances. Consumers should key records by `qid` only after resolving these conflicts; silently keeping the first or last record can select different questions. This notice should be removed once the four QID conflicts are corrected in the release files.
+The release contains **2,280 unique QIDs**. Four QIDs in the current Temporal source are each attached to two distinct QA records, so the physical Temporal row count is 730 rather than 726. The manifest preserves all 730 records and marks their `qid_occurrences`; it does not silently discard either record. The affected QIDs are listed in `dataset_index.json`.
 
 ## Evaluation
 
@@ -177,4 +169,3 @@ The manuscript is currently anonymized. Please cite **“Deeply Interleaved Text
   note         = {Anonymous manuscript}
 }
 ```
-

ticbench_loader.py

@@ -0,0 +1,69 @@
+"""Small dependency-free helpers for the TIC-Bench sharded release."""
+
+from __future__ import annotations
+
+import json
+import tarfile
+from pathlib import Path
+from typing import Iterator
+
+
+DOMAINS = {"spatial", "logical", "temporal"}
+
+
+def iter_manifest(root: str | Path, domain: str | None = None) -> Iterator[dict]:
+    """Yield manifest rows, optionally restricted to one paper-facing domain."""
+    if domain is not None and domain not in DOMAINS:
+        raise ValueError(f"domain must be one of {sorted(DOMAINS)}")
+    path = Path(root) / "data" / "manifest.jsonl"
+    with path.open(encoding="utf-8") as stream:
+        for line in stream:
+            if not line.strip():
+                continue
+            row = json.loads(line)
+            if domain is None or row["domain"] == domain:
+                yield row
+
+
+def find_qid(root: str | Path, qid: str) -> list[dict]:
+    """Return every manifest occurrence of a QID (duplicates are preserved)."""
+    return [row for row in iter_manifest(root) if row["qid"] == qid]
+
+
+def domain_shards(root: str | Path, domain: str) -> list[Path]:
+    """Return the ordered local shard paths for a domain."""
+    if domain not in DOMAINS:
+        raise ValueError(f"domain must be one of {sorted(DOMAINS)}")
+    return sorted((Path(root) / "data").glob(f"ticbench-{domain}-*.tar"))
+
+
+def _safe_destination(output_dir: Path, member_name: str) -> Path:
+    destination = (output_dir / member_name).resolve()
+    root = output_dir.resolve()
+    if destination != root and root not in destination.parents:
+        raise ValueError(f"unsafe path in tar archive: {member_name!r}")
+    return destination
+
+
+def extract_domain(
+    root: str | Path,
+    domain: str,
+    output_dir: str | Path,
+) -> Path:
+    """Safely extract every locally downloaded shard for one domain."""
+    output = Path(output_dir)
+    output.mkdir(parents=True, exist_ok=True)
+    shards = domain_shards(root, domain)
+    if not shards:
+        raise FileNotFoundError(
+            f"no local {domain!r} shards found under {Path(root) / 'data'}"
+        )
+    for shard in shards:
+        with tarfile.open(shard, mode="r:") as archive:
+            members = archive.getmembers()
+            for member in members:
+                _safe_destination(output, member.name)
+                if member.issym() or member.islnk():
+                    raise ValueError(f"links are not allowed in release shards: {member.name!r}")
+            archive.extractall(output, members=members)
+    return output