Convert to Parquet format for Dataset Viewer compatibility

HuggingFace deprecated custom loading scripts. Switching to Parquet format with auto-loading:

Changes:
- Remove deprecated scripts: HERBench.py, herbench.py
- Add Parquet files with Git LFS: herbench_full.parquet (4.87 MB), herbench_lite.parquet (1.02 MB)
- Update README.md YAML to use Parquet with explicit configs
- Add comprehensive data format documentation and usage examples
- Update .gitattributes to track Parquet files with Git LFS
- Keep original JSON files for users who need raw format

Parquet format ensures:
- Reliable schema handling (fixes Arrow conversion errors)
- Better performance for large datasets
- Full compatibility with HF Dataset Viewer
- Support for varying metadata structures across task types

.gitattributes

@@ -1,5 +1,4 @@
 # Git LFS configuration for large files
-
 # Videos and archives (to be uploaded via HF CLI)
 *.tar.part.* filter=lfs diff=lfs merge=lfs -text
 *.tar filter=lfs diff=lfs merge=lfs -text
@@ -7,13 +6,13 @@
 *.avi filter=lfs diff=lfs merge=lfs -text
 *.mov filter=lfs diff=lfs merge=lfs -text
 *.mkv filter=lfs diff=lfs merge=lfs -text
-
 # Image files (to be uploaded via HF CLI)
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
-
 # Large annotation files (to be uploaded via HF CLI)
 data/herbench_annotations.json filter=lfs diff=lfs merge=lfs -text
 data/herbench_annotations_lite.json filter=lfs diff=lfs merge=lfs -text
 data/*.json filter=lfs diff=lfs merge=lfs -text
+# Parquet files
+data/*.parquet filter=lfs diff=lfs merge=lfs -text

HERBench.py

@@ -1,194 +0,0 @@
-"""
-HERBench Hugging Face Datasets loading script.
-
-Why this file exists:
-- Hugging Face Dataset Viewer auto-parses JSON files if no loading script is detected.
-- Auto-parsing uses pandas->pyarrow inference and can fail when nested fields (like `metadata`)
-  have inconsistent shapes across rows (common in multi-task benchmarks).
-- By providing a proper datasets loading script named after the repo (`herbench.py` for HERBench),
-  the Hub will use this builder instead, with an explicit, stable schema.
-
-This script ensures streaming compatibility and robust schema handling for the Dataset Viewer.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, Iterator
-
-import datasets
-
-
-_DESCRIPTION = """\
-HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering.
-
-This dataset contains multiple-choice questions grounded in long videos and designed to
-require integration of multiple temporally separated cues (high evidential requirement).
-"""
-
-_HOMEPAGE = "https://github.com/DanBenAmi/HERBench"
-_LICENSE = "CC-BY-NC-SA-4.0"
-
-_CITATION = """\
-@article{herbench2025,
-  title={HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering},
-  author={Ben-Ami, Dan and Serussi, Gabriele and Cohen, Kobi and Baskin, Chaim},
-  journal={arXiv preprint arXiv:XXXX.XXXXX},
-  year={2025}
-}
-"""
-
-_VERSION = "1.0.3"
-
-
-class HERBenchConfig(datasets.BuilderConfig):
-    """BuilderConfig for HERBench."""
-    pass
-
-
-class HERBench(datasets.GeneratorBasedBuilder):
-    """HERBench Dataset: Multi-Evidence Integration in Video QA."""
-
-    VERSION = datasets.Version(_VERSION)
-
-    BUILDER_CONFIGS = [
-        HERBenchConfig(
-            name="full",
-            version=VERSION,
-            description="Full HERBench dataset (27,936 questions; 335 videos; ~161GB).",
-        ),
-        HERBenchConfig(
-            name="lite",
-            version=VERSION,
-            description="HERBench-Lite subset (~5,600 questions; ~67 videos; ~35GB for quick prototyping).",
-        ),
-    ]
-
-    # Make the Hub viewer default to the smaller config (faster and less error-prone).
-    DEFAULT_CONFIG_NAME = "lite"
-
-    def _info(self) -> datasets.DatasetInfo:
-        """
-        Define the dataset schema with strict, stable types for all fields.
-
-        IMPORTANT: Keep features stable across all rows.
-        `metadata` in the raw JSON varies by task (different keys / nested lists).
-        To keep the schema consistent for Arrow + Dataset Viewer:
-        - Expose common metadata fields as flat, typed columns
-        - Store the full raw metadata dict as a JSON string in `metadata_json`
-        """
-        features = datasets.Features(
-            {
-                # Core fields
-                "question_id": datasets.Value("string"),
-                "video_id": datasets.Value("string"),
-                "video_path": datasets.Value("string"),
-                "question": datasets.Value("string"),
-                "choices": datasets.Sequence(datasets.Value("string")),
-                "answer": datasets.Value("string"),
-                "answer_index": datasets.Value("int32"),
-                "answer_text": datasets.Value("string"),
-                "task_type": datasets.Value("string"),
-
-                # Common metadata fields (flat, typed)
-                "source_dataset": datasets.Value("string"),
-                "duration": datasets.Value("float32"),
-                "resolution": datasets.Value("string"),
-
-                # Full raw metadata as JSON string (stable schema)
-                "metadata_json": datasets.Value("string"),
-            }
-        )
-
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-            version=self.VERSION,
-        )
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager):
-        """
-        Define data splits. Downloads only the JSON annotations for streaming efficiency.
-        Videos are referenced by path but not downloaded during viewer loading.
-        """
-        if self.config.name == "lite":
-            annotations_file = "data/herbench_annotations_lite.json"
-        else:
-            annotations_file = "data/herbench_annotations.json"
-
-        # Download only annotations (not videos) for Dataset Viewer efficiency
-        data_files = dl_manager.download(
-            {
-                "annotations": annotations_file,
-            }
-        )
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"annotations_file": data_files["annotations"]},
-            )
-        ]
-
-    def _generate_examples(self, annotations_file: str) -> Iterator[tuple[int, Dict[str, Any]]]:
-        """
-        Yield examples from the annotations file with robust type handling.
-
-        This method ensures:
-        - Streaming compatibility (processes one example at a time)
-        - Stable schema (all fields have consistent types)
-        - Defensive parsing (handles missing/malformed fields gracefully)
-        """
-        with open(annotations_file, encoding="utf-8") as f:
-            annotations = json.load(f)
-
-        for idx, ann in enumerate(annotations):
-            # Extract and normalize metadata
-            md = ann.get("metadata")
-            if md is None or not isinstance(md, dict):
-                # Defensive: ensure metadata is always a dict
-                md = {}
-
-            # Extract common metadata fields with defaults
-            source_dataset = md.get("source_dataset", "unknown")
-            duration = md.get("duration", 0.0)
-            resolution = md.get("resolution", "unknown")
-
-            # Normalize numeric types to avoid Arrow type inference issues
-            try:
-                duration_f = float(duration) if duration is not None else 0.0
-            except (ValueError, TypeError):
-                duration_f = 0.0
-
-            # Normalize choices field
-            choices = ann.get("choices", [])
-            if not isinstance(choices, list):
-                choices = []
-
-            # Normalize answer_index
-            answer_index = ann.get("answer_index", 0)
-            try:
-                answer_index = int(answer_index) if answer_index is not None else 0
-            except (ValueError, TypeError):
-                answer_index = 0
-
-            yield idx, {
-                "question_id": str(ann.get("question_id", f"HER_{idx:06d}")),
-                "video_id": str(ann.get("video_id", "")),
-                "video_path": str(ann.get("video_path", "")),
-                "question": str(ann.get("question", "")),
-                "choices": [str(x) for x in choices],
-                "answer": str(ann.get("answer", "")),
-                "answer_index": answer_index,
-                "answer_text": str(ann.get("answer_text", "")),
-                "task_type": str(ann.get("task_type", "unknown")),
-                "source_dataset": str(source_dataset),
-                "duration": duration_f,
-                "resolution": str(resolution),
-                "metadata_json": json.dumps(md, ensure_ascii=False),
-            }
-
-

README.md

@@ -15,6 +15,16 @@ tags:
 size_categories:
 - 10K<n<100K
 pretty_name: HERBench
+configs:
+- config_name: full
+  data_files:
+  - split: test
+    path: data/herbench_full.parquet
+  default: true
+- config_name: lite
+  data_files:
+  - split: test
+    path: data/herbench_lite.parquet
 ---
 
 # HERBench: Multi-Evidence Integration in Video Question Answering
@@ -245,9 +255,9 @@ pip install huggingface-hub
 # Download FULL version (27,936 questions, ~161 GB)
 huggingface-cli download DanBenAmi/HERBench --repo-type dataset --local-dir HERBench
 
-# Download LITE version only (5,600 questions, ~35 GB)
+# Download LITE version only (~5,600 questions, ~35 GB videos)
 huggingface-cli download DanBenAmi/HERBench \
-    --include "data/herbench_annotations_lite.json" \
+    --include "data/herbench_lite.parquet" \
     --include "data/*metadata.json" \
     --include "videos/videos.tar.part.00" \
     --include "videos/videos.tar.part.01" \
@@ -257,24 +267,54 @@ huggingface-cli download DanBenAmi/HERBench \
     --include "videos/videos.tar.checksums.txt" \
     --local-dir HERBench
 
-# Or download only annotations (no videos)
-huggingface-cli download DanBenAmi/HERBench --include "data/*" --local-dir HERBench
+# Or download only annotations (no videos, ~6 MB)
+huggingface-cli download DanBenAmi/HERBench --include "data/*.parquet" --include "data/*metadata.json" --local-dir HERBench
 ```
 
-#### Option B: Using Python
+#### Option B: Using Python (Datasets Library)
+
+The dataset is provided in **Parquet format** for optimal compatibility with HuggingFace Datasets and reliable schema handling.
 
 ```python
 from datasets import load_dataset
 
-# Load FULL version (default)
-dataset_full = load_dataset("DanBenAmi/HERBench", name="full")
+# Load FULL version (default) - 27,936 questions
+dataset_full = load_dataset("DanBenAmi/HERBench", "full")
 print(f"Total questions: {len(dataset_full['test'])}")
 
-# Load LITE version
-dataset_lite = load_dataset("DanBenAmi/HERBench", name="lite")
-print(f"Total questions: {len(dataset_lite['test'])}")
+# Access test split
+test_data = dataset_full["test"]
+
+# Get a single example
+example = test_data[0]
+print(f"Question: {example['question']}")
+print(f"Choices: {example['choices']}")
+print(f"Answer: {example['answer']}")
+print(f"Task: {example['task_type']}")
+print(f"Video: {example['video_path']}")
+
+# Load LITE version - ~5,600 questions (20% sample)
+dataset_lite = load_dataset("DanBenAmi/HERBench", "lite")
+print(f"Lite questions: {len(dataset_lite['test'])}")
 ```
 
+**Schema:** Each example contains:
+- `question_id` - Unique question identifier
+- `video_id` - Video identifier
+- `video_path` - Path to video file
+- `question` - Question text
+- `choices` - List of 5 multiple-choice options
+- `answer` - Correct answer (A/B/C/D/E)
+- `answer_index` - Zero-indexed answer position (0-4)
+- `answer_text` - Answer value
+- `task_type` - Task category name
+- `source_dataset` - Source dataset name
+- `duration` - Video duration in seconds (float)
+- `resolution` - Video resolution (width x height)
+- `metadata_json` - Full metadata as JSON string
+
+**Note:** Original JSON files are also available in the `data/` folder for users who need the raw format for custom processing.
+
 ### 2. Extract Videos
 
 #### For Full Version:

data/herbench_full.parquet

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

data/herbench_lite.parquet

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

herbench.py

@@ -1,194 +0,0 @@
-"""
-HERBench Hugging Face Datasets loading script.
-
-Why this file exists:
-- Hugging Face Dataset Viewer auto-parses JSON files if no loading script is detected.
-- Auto-parsing uses pandas->pyarrow inference and can fail when nested fields (like `metadata`)
-  have inconsistent shapes across rows (common in multi-task benchmarks).
-- By providing a proper datasets loading script named after the repo (`herbench.py` for HERBench),
-  the Hub will use this builder instead, with an explicit, stable schema.
-
-This script ensures streaming compatibility and robust schema handling for the Dataset Viewer.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any, Dict, Iterator
-
-import datasets
-
-
-_DESCRIPTION = """\
-HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering.
-
-This dataset contains multiple-choice questions grounded in long videos and designed to
-require integration of multiple temporally separated cues (high evidential requirement).
-"""
-
-_HOMEPAGE = "https://github.com/DanBenAmi/HERBench"
-_LICENSE = "CC-BY-NC-SA-4.0"
-
-_CITATION = """\
-@article{herbench2025,
-  title={HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering},
-  author={Ben-Ami, Dan and Serussi, Gabriele and Cohen, Kobi and Baskin, Chaim},
-  journal={arXiv preprint arXiv:XXXX.XXXXX},
-  year={2025}
-}
-"""
-
-_VERSION = "1.0.3"
-
-
-class HERBenchConfig(datasets.BuilderConfig):
-    """BuilderConfig for HERBench."""
-    pass
-
-
-class HERBench(datasets.GeneratorBasedBuilder):
-    """HERBench Dataset: Multi-Evidence Integration in Video QA."""
-
-    VERSION = datasets.Version(_VERSION)
-
-    BUILDER_CONFIGS = [
-        HERBenchConfig(
-            name="full",
-            version=VERSION,
-            description="Full HERBench dataset (27,936 questions; 335 videos; ~161GB).",
-        ),
-        HERBenchConfig(
-            name="lite",
-            version=VERSION,
-            description="HERBench-Lite subset (~5,600 questions; ~67 videos; ~35GB for quick prototyping).",
-        ),
-    ]
-
-    # Make the Hub viewer default to the smaller config (faster and less error-prone).
-    DEFAULT_CONFIG_NAME = "lite"
-
-    def _info(self) -> datasets.DatasetInfo:
-        """
-        Define the dataset schema with strict, stable types for all fields.
-
-        IMPORTANT: Keep features stable across all rows.
-        `metadata` in the raw JSON varies by task (different keys / nested lists).
-        To keep the schema consistent for Arrow + Dataset Viewer:
-        - Expose common metadata fields as flat, typed columns
-        - Store the full raw metadata dict as a JSON string in `metadata_json`
-        """
-        features = datasets.Features(
-            {
-                # Core fields
-                "question_id": datasets.Value("string"),
-                "video_id": datasets.Value("string"),
-                "video_path": datasets.Value("string"),
-                "question": datasets.Value("string"),
-                "choices": datasets.Sequence(datasets.Value("string")),
-                "answer": datasets.Value("string"),
-                "answer_index": datasets.Value("int32"),
-                "answer_text": datasets.Value("string"),
-                "task_type": datasets.Value("string"),
-
-                # Common metadata fields (flat, typed)
-                "source_dataset": datasets.Value("string"),
-                "duration": datasets.Value("float32"),
-                "resolution": datasets.Value("string"),
-
-                # Full raw metadata as JSON string (stable schema)
-                "metadata_json": datasets.Value("string"),
-            }
-        )
-
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=features,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-            version=self.VERSION,
-        )
-
-    def _split_generators(self, dl_manager: datasets.DownloadManager):
-        """
-        Define data splits. Downloads only the JSON annotations for streaming efficiency.
-        Videos are referenced by path but not downloaded during viewer loading.
-        """
-        if self.config.name == "lite":
-            annotations_file = "data/herbench_annotations_lite.json"
-        else:
-            annotations_file = "data/herbench_annotations.json"
-
-        # Download only annotations (not videos) for Dataset Viewer efficiency
-        data_files = dl_manager.download(
-            {
-                "annotations": annotations_file,
-            }
-        )
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={"annotations_file": data_files["annotations"]},
-            )
-        ]
-
-    def _generate_examples(self, annotations_file: str) -> Iterator[tuple[int, Dict[str, Any]]]:
-        """
-        Yield examples from the annotations file with robust type handling.
-
-        This method ensures:
-        - Streaming compatibility (processes one example at a time)
-        - Stable schema (all fields have consistent types)
-        - Defensive parsing (handles missing/malformed fields gracefully)
-        """
-        with open(annotations_file, encoding="utf-8") as f:
-            annotations = json.load(f)
-
-        for idx, ann in enumerate(annotations):
-            # Extract and normalize metadata
-            md = ann.get("metadata")
-            if md is None or not isinstance(md, dict):
-                # Defensive: ensure metadata is always a dict
-                md = {}
-
-            # Extract common metadata fields with defaults
-            source_dataset = md.get("source_dataset", "unknown")
-            duration = md.get("duration", 0.0)
-            resolution = md.get("resolution", "unknown")
-
-            # Normalize numeric types to avoid Arrow type inference issues
-            try:
-                duration_f = float(duration) if duration is not None else 0.0
-            except (ValueError, TypeError):
-                duration_f = 0.0
-
-            # Normalize choices field
-            choices = ann.get("choices", [])
-            if not isinstance(choices, list):
-                choices = []
-
-            # Normalize answer_index
-            answer_index = ann.get("answer_index", 0)
-            try:
-                answer_index = int(answer_index) if answer_index is not None else 0
-            except (ValueError, TypeError):
-                answer_index = 0
-
-            yield idx, {
-                "question_id": str(ann.get("question_id", f"HER_{idx:06d}")),
-                "video_id": str(ann.get("video_id", "")),
-                "video_path": str(ann.get("video_path", "")),
-                "question": str(ann.get("question", "")),
-                "choices": [str(x) for x in choices],
-                "answer": str(ann.get("answer", "")),
-                "answer_index": answer_index,
-                "answer_text": str(ann.get("answer_text", "")),
-                "task_type": str(ann.get("task_type", "unknown")),
-                "source_dataset": str(source_dataset),
-                "duration": duration_f,
-                "resolution": str(resolution),
-                "metadata_json": json.dumps(md, ensure_ascii=False),
-            }
-
-