Switch to data-files viewer workflow

README.md

@@ -1,21 +1,64 @@
 ---
 annotations_creators:
-  - expert-generated
+- expert-generated
 language_creators:
-  - other
+- other
 language: en
 license: cc-by-4.0
 multilinguality:
-  - monolingual
+- monolingual
 size_categories:
-  - 1K<n<10K
+- 1K<n<10K
 source_datasets:
-  - combination
+- combination
 task_categories:
-  - other
+- other
 task_ids:
-  - multi-label-classification
+- multi-label-classification
 pretty_name: CUEBench
+configs:
+- config_name: clue
+  default: true
+  data_files:
+  - split: train
+    path: data/clue/train.jsonl
+- config_name: mep
+  data_files:
+  - split: train
+    path: data/mep/train.jsonl
+dataset_info:
+- config_name: clue
+  features:
+  - name: image_id
+    dtype: string
+  - name: observed_classes
+    sequence: string
+  - name: target_classes
+    sequence: string
+  - name: image_path
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 1101143
+    num_examples: 1648
+  download_size: 1101143
+  dataset_size: 1101143
+- config_name: mep
+  features:
+  - name: image_id
+    dtype: string
+  - name: observed_classes
+    sequence: string
+  - name: target_classes
+    sequence: string
+  - name: image_path
+    dtype: string
+  splits:
+  - name: train
+    num_bytes: 845579
+    num_examples: 1216
+  download_size: 845579
+  dataset_size: 845579
 ---
 
 # CUEBench: Contextual Unobserved Entity Benchmark
@@ -33,8 +76,8 @@ CUEBench is a neurosymbolic benchmark that emphasizes **contextual entity predic
 
 | Config | File | Description |
 | --- | --- | --- |
-| `clue` *(default)* | `clue_metadata.jsonl` | Contextual Unobserved Entity (CLUE) frames with heavy occlusions and single-target predictions. |
-| `mep` | `mep_metadata.jsonl` | Multi-Entity Prediction (MEP) split that introduces complementary metadata and more diverse target sets. |
+| `clue` *(default)* | `data/clue/train.jsonl` | Contextual Unobserved Entity (CLUE) frames with heavy occlusions and single-target predictions. |
+| `mep` | `data/mep/train.jsonl` | Multi-Entity Prediction (MEP) split that introduces complementary metadata and more diverse target sets. |
 
 When this dataset is viewed on Hugging Face, the dataset viewer automatically exposes a **config dropdown** so you can switch between `clue` and `mep` without leaving the UI.
 
@@ -82,13 +125,27 @@ dataset = load_dataset(
 from datasets import load_dataset
 
 dataset = load_dataset(
-  path="cuebench",
-  data_files="clue_metadata.jsonl",  # swap with "mep_metadata.jsonl" as needed
+  path="json",
+  data_files={"train": "data/clue/train.jsonl"},  # swap with data/mep/train.jsonl
   split="train",
 )
 ```
 
-> **Tip:** From source, you can still switch configurations by pointing `data_files` to `clue_metadata.jsonl` or `mep_metadata.jsonl`.
+> **Tip:** From source, you can still switch configurations by pointing `data_files` to `data/mep/train.jsonl`.
+
+### Regenerating viewer files
+
+The repository keeps the original metadata dumps under `raw/`. To refresh the
+viewer-friendly JSONL files (e.g. after updating the raw annotations), run:
+
+```bash
+/.venv/bin/python scripts/build_viewer_files.py
+```
+
+This script adds the derived columns (`image_id`, `observed_classes`, etc.) and
+drops the converted files into `data/clue/train.jsonl` and
+`data/mep/train.jsonl`. It also updates `data/stats.json`, which is referenced by
+the dataset card to keep `dataset_info` counters accurate.
 
 ## Metrics
 
@@ -96,7 +153,7 @@ dataset = load_dataset(
 
 ## Licensing
 
-The dataset is currently tagged as **CC-BY-4.0** in `cuebench.py`. Update this section if you select a different license.
+The dataset is currently tagged as **CC-BY-4.0**. Update this section if you select a different license.
 
 ## Citation
 
@@ -116,10 +173,15 @@ The dataset is currently tagged as **CC-BY-4.0** in `cuebench.py`. Update this s
    ```
    cuebench/
      README.md
-     cuebench.py
-     clue_metadata.jsonl
-     mep_metadata.jsonl
+    data/
+      clue/train.jsonl
+      mep/train.jsonl
+    raw/
+      clue_metadata.jsonl
+      mep_metadata.jsonl
      metric.py           # optional metric script
+    scripts/build_viewer_files.py
+    scripts/push_to_hub.py
      images/...          # optional or host separately
    ```
 4. Initialize Git + LFS:
@@ -133,11 +195,9 @@ The dataset is currently tagged as **CC-BY-4.0** in `cuebench.py`. Update this s
    git commit -m "Initial CUEBench dataset"
    git push origin main
    ```
-5. Validate locally before pushing updates (optional but recommended):
-   - `datasets-cli test ./cuebench.py --all_configs`
-   - `python -m datasets.prepare_module ./cuebench.py`
-6. On the Hub page, trigger the dataset preview to ensure the loader runs.
-7. (Optional) Publish the metric under `metrics/cuebench-metric` following the Metrics Hub template and link it from the dataset card.
+5. Regenerate viewer files anytime the raw metadata changes: `/.venv/bin/python scripts/build_viewer_files.py`
+6. Push the prepared splits to the Hub (per config) using `/.venv/bin/python scripts/push_to_hub.py --repo ishwarbb23/cuebench`
+7. On the Hub page, trigger the dataset preview to ensure the loader runs.
+8. (Optional) Publish the metric under `metrics/cuebench-metric` following the Metrics Hub template and link it from the dataset card.
 
 Update these steps with any organization-specific tooling you use.
-

cuebench.py

@@ -1,135 +0,0 @@
-import json
-import os
-
-from datasets import (
-    BuilderConfig,
-    DatasetInfo,
-    Features,
-    GeneratorBasedBuilder,
-    Sequence,
-    Split,
-    SplitGenerator,
-    Value,
-    Version,
-)
-from fsspec.implementations.local import LocalFileSystem
-
-HF_DATA_BASE_URL = "https://huggingface.co/datasets/ishwarbb23/cuebench/resolve/main"
-DATA_BASE_OVERRIDE = os.getenv("CUEBENCH_DATA_BASE_URL")
-CLUE_METADATA_FILENAME = "clue_metadata.jsonl"
-MEP_METADATA_FILENAME = "mep_metadata.jsonl"
-
-
-class CUEBenchConfig(BuilderConfig):
-    """Builder config that carries the backing metadata file."""
-
-    def __init__(self, *, data_files=None, **kwargs):
-        super().__init__(**kwargs)
-        self.data_files = data_files or {"train": CLUE_METADATA_FILENAME}
-
-
-class CUEBench(GeneratorBasedBuilder):
-    VERSION = Version("1.0.0")
-    BUILDER_CONFIGS = [
-        CUEBenchConfig(
-            name="clue",
-            version=VERSION,
-            description="Contextual Unobserved Entity (CLUE) split with occluded-entity targets.",
-            data_files={"train": CLUE_METADATA_FILENAME},
-        ),
-        CUEBenchConfig(
-            name="mep",
-            version=VERSION,
-            description="Multi-Entity Prediction (MEP) split with complementary metadata.",
-            data_files={"train": MEP_METADATA_FILENAME},
-        ),
-    ]
-    DEFAULT_CONFIG_NAME = "clue"
-
-    def _info(self):
-        return DatasetInfo(
-            description="CUEBench: Contextual Entity Prediction for Occluded or Unobserved Entities in Autonomous Driving.",
-            features=Features({
-                "image_id": Value("string"),
-                "observed_classes": Sequence(Value("string")),  # Properly represent lists
-                "target_classes": Sequence(Value("string")),
-                "image_path": Value("string")
-            }),
-            citation="@misc{cuebench2025, title={CUEBench: Contextual Unobserved Entity Benchmark}, year={2025}, author={CUEBench Authors}}",
-            homepage="https://huggingface.co/datasets/ishwarbb23/cuebench",
-            license="CC-BY-4.0",
-        )
-
-    def _split_generators(self, dl_manager):
-        data_files = self.config.data_files or {"train": CLUE_METADATA_FILENAME}
-        train_files = data_files["train"] if isinstance(data_files, dict) else data_files
-        if isinstance(train_files, str):
-            train_files = [train_files]
-
-        resolved_files = [self._resolve_path(file_path, dl_manager) for file_path in train_files]
-
-        return [SplitGenerator(name=Split.TRAIN, gen_kwargs={"filepaths": resolved_files})]
-
-    def _resolve_path(self, file_path, dl_manager):
-        if file_path.startswith(("http://", "https://")):
-            resolved = dl_manager.download_and_extract(file_path)
-            return resolved[0] if isinstance(resolved, list) else resolved
-
-        local_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), file_path)
-        if os.path.exists(local_path):
-            return local_path
-
-        if DATA_BASE_OVERRIDE:
-            override = DATA_BASE_OVERRIDE.rstrip("/")
-            if override.startswith(("http://", "https://", "hf://")):
-                remote_path = f"{override}/{file_path}"
-                resolved = dl_manager.download_and_extract(remote_path)
-                return resolved[0] if isinstance(resolved, list) else resolved
-
-            override_candidate = os.path.join(override, file_path)
-            if os.path.exists(override_candidate):
-                return override_candidate
-
-        remote_path = f"{HF_DATA_BASE_URL}/{file_path}"
-        resolved = dl_manager.download_and_extract(remote_path)
-        return resolved[0] if isinstance(resolved, list) else resolved
-
-    def _generate_examples(self, filepaths):
-        if isinstance(filepaths, str):
-            filepaths = [filepaths]
-
-        idx = 0
-        for filepath in filepaths:
-            with open(filepath, "r", encoding="utf-8") as f:
-                for line in f:
-                    example = json.loads(line)
-                    image_id = example.get("aligned_id") or example.get("image_id")
-                    if image_id is None:
-                        raise ValueError(f"Missing image identifier for example at line {idx}.")
-                    yield idx, {
-                        "image_id": image_id,
-                        "image_path": example["image_path"],
-                        "observed_classes": example["detected_classes"],
-                        "target_classes": example["target_classes"],
-                    }
-                    idx += 1
-
-    def _ensure_local_fs_protocol(self):
-        if isinstance(getattr(self, "_fs", None), LocalFileSystem):
-            protocol = getattr(self._fs, "protocol", None)
-            if protocol != "file":
-                self._fs.protocol = "file"
-            output_dir = getattr(self, "_output_dir", None)
-            if isinstance(output_dir, str):
-                stripped = self._fs._strip_protocol(output_dir)
-                if stripped:
-                    self._output_dir = stripped
-
-    def _download_and_prepare(self, *args, **kwargs):
-        result = super()._download_and_prepare(*args, **kwargs)
-        self._ensure_local_fs_protocol()
-        return result
-
-    def as_dataset(self, *args, **kwargs):
-        self._ensure_local_fs_protocol()
-        return super().as_dataset(*args, **kwargs)

data/clue/train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efa1537ff34d0d2b5f72e922e84f8cfa4114b1fb185025908d10cca04add5166
+size 1101143

data/mep/train.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8efcec1604098a9072d2848afaf4141a47a072760f1d19e28bab0e45b6020cf
+size 845579

data/stats.json

@@ -0,0 +1,14 @@
+{
+  "clue": {
+    "num_examples": 1648,
+    "num_bytes": 1101143,
+    "source_path": "raw/clue_metadata.jsonl",
+    "output_path": "data/clue/train.jsonl"
+  },
+  "mep": {
+    "num_examples": 1216,
+    "num_bytes": 845579,
+    "source_path": "raw/mep_metadata.jsonl",
+    "output_path": "data/mep/train.jsonl"
+  }
+}

scripts/build_viewer_files.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Utilities to convert the raw metadata dumps into viewer-friendly JSONL files."""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Dict, Iterator, MutableMapping
+
+ROOT = Path(__file__).resolve().parents[1]
+RAW_DIR = ROOT / "raw"
+OUTPUT_DIR = ROOT / "data"
+
+CONFIG_SOURCES: Dict[str, Path] = {
+    "clue": RAW_DIR / "clue_metadata.jsonl",
+    "mep": RAW_DIR / "mep_metadata.jsonl",
+}
+
+@dataclass
+class BuildStats:
+    """Simple container for summary numbers we surface in README/stats.json."""
+
+    num_examples: int
+    num_bytes: int
+    source_path: str
+    output_path: str
+
+    def as_dict(self) -> Dict[str, object]:
+        return asdict(self)
+
+
+def _normalize_record(record: MutableMapping[str, object]) -> MutableMapping[str, object]:
+    """Add the columns expected by the README and dataset viewer."""
+
+    image_id = record.get("aligned_id") or record.get("image_id")
+    if image_id is None:
+        seq = record.get("seq_name", "seq")
+        frame = record.get("frame_count", 0)
+        image_id = f"{seq}.{int(frame):05d}"
+    record["image_id"] = image_id
+
+    observed = record.get("observed_classes") or record.get("detected_classes") or []
+    record["observed_classes"] = observed
+    # Preserve the detected_classes alias so legacy tooling keeps working.
+    record.setdefault("detected_classes", observed)
+
+    record["target_classes"] = record.get("target_classes", [])
+    record["image_path"] = record.get("image_path")
+    return record
+
+
+def _iter_records(path: Path) -> Iterator[MutableMapping[str, object]]:
+    with path.open("r", encoding="utf-8") as src:
+        for line in src:
+            if not line.strip():
+                continue
+            yield json.loads(line)
+
+
+def build_split(config_name: str, source_path: Path, output_path: Path) -> BuildStats:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    count = 0
+    with output_path.open("w", encoding="utf-8") as dst:
+        for record in _iter_records(source_path):
+            normalized = _normalize_record(record)
+            dst.write(json.dumps(normalized, ensure_ascii=False) + "\n")
+            count += 1
+    num_bytes = output_path.stat().st_size
+    return BuildStats(
+        num_examples=count,
+        num_bytes=num_bytes,
+        source_path=str(source_path.relative_to(ROOT)),
+        output_path=str(output_path.relative_to(ROOT)),
+    )
+
+
+def main() -> None:
+    stats: Dict[str, Dict[str, object]] = {}
+    for config_name, source in CONFIG_SOURCES.items():
+        if not source.exists():
+            raise FileNotFoundError(f"Missing source file for {config_name}: {source}")
+        output_path = OUTPUT_DIR / config_name / "train.jsonl"
+        summary = build_split(config_name, source, output_path)
+        stats[config_name] = summary.as_dict()
+        print(
+            f"[{config_name}] wrote {summary.num_examples} examples -> {summary.output_path} "
+            f"({summary.num_bytes} bytes)."
+        )
+    stats_path = OUTPUT_DIR / "stats.json"
+    with stats_path.open("w", encoding="utf-8") as handle:
+        json.dump(stats, handle, indent=2)
+        handle.write("\n")
+    print(f"Wrote summary stats to {stats_path.relative_to(ROOT)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/push_to_hub.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""Upload the prepared viewer files to the Hugging Face Hub."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Dict
+
+from datasets import Dataset
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = ROOT / "data"
+CONFIGS = {
+    "clue": DATA_DIR / "clue" / "train.jsonl",
+    "mep": DATA_DIR / "mep" / "train.jsonl",
+}
+
+
+def read_stats() -> Dict[str, Dict[str, int]]:
+    stats_path = DATA_DIR / "stats.json"
+    if not stats_path.exists():
+        return {}
+    with stats_path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def push_config(config_name: str, file_path: Path, repo_id: str, args: argparse.Namespace) -> None:
+    if not file_path.exists():
+        raise FileNotFoundError(f"Missing file for config '{config_name}': {file_path}")
+    print(f"Loading {config_name} from {file_path.relative_to(ROOT)} ...")
+    dataset = Dataset.from_json(str(file_path))
+    dataset.push_to_hub(
+        repo_id=repo_id,
+        config_name=config_name,
+        split=args.split,
+        private=args.private,
+        token=args.token,
+        branch=args.branch,
+        max_shard_size=args.max_shard_size,
+    )
+    print(f"✓ Uploaded {config_name}/{args.split} to {repo_id}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo", required=True, help="Target dataset repo id, e.g. user/cuebench")
+    parser.add_argument("--split", default="train", help="Split name to register on the Hub (default: train)")
+    parser.add_argument("--branch", default=None, help="Optional branch to push to (defaults to repo default)")
+    parser.add_argument("--token", default=None, help="HuggingFace token; omit if already logged in via CLI")
+    parser.add_argument("--private", action="store_true", help="Mark the uploaded dataset as private")
+    parser.add_argument("--max-shard-size", default="500MB", help="Shard threshold passed to push_to_hub")
+    args = parser.parse_args()
+
+    stats = read_stats()
+    for config_name, path in CONFIGS.items():
+        push_config(config_name, path, args.repo, args)
+        if config_name in stats:
+            summary = stats[config_name]
+            print(
+                f"  ↳ stats: {summary.get('num_examples', '?')} examples, "
+                f"{summary.get('num_bytes', '?')} bytes"
+            )
+
+
+if __name__ == "__main__":
+    main()