Fix HF Dataset Viewer: add hub loader script

README.md

@@ -189,7 +189,7 @@ HERBench/
 │   ├── videos.tar.part.XX               # |
 │   ├── videos.tar.checksums.txt         # SHA256 checksums
 │   └── videos_lite_info.txt             # Info about archive structure
-└── herbench_loader.py                   # Python dataloader (supports both)
+├── herbench.py                          # HF Hub loading script (powers Dataset Viewer)
 ```
 
 **Archive Structure:** Videos are organized so that Lite videos are in the first archive parts (00-03), and Full-only videos are in the remaining parts. This allows efficient downloading of either version without duplication.

herbench.py

@@ -0,0 +1,168 @@
+"""
+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.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, Iterator, Optional
+
+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.1"
+
+
+class HERBenchConfig(datasets.BuilderConfig):
+    """BuilderConfig for HERBench."""
+
+
+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 (all questions; large video collection).",
+        ),
+        HERBenchConfig(
+            name="lite",
+            version=VERSION,
+            description="HERBench-Lite subset (smaller for quick prototyping and the Dataset Viewer).",
+        ),
+    ]
+
+    # Make the Hub viewer default to the smaller config (faster and less error-prone).
+    DEFAULT_CONFIG_NAME = "lite"
+
+    def _info(self) -> datasets.DatasetInfo:
+        # 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 a few common metadata fields as flat columns
+        # - store the full raw metadata dict as a JSON string in `metadata_json`
+        features = datasets.Features(
+            {
+                "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 (flat)
+                "source_dataset": datasets.Value("string"),
+                "duration": datasets.Value("float32"),
+                "resolution": datasets.Value("string"),
+                "evidence_count": datasets.Value("int32"),
+                "difficulty": datasets.Value("string"),
+                # Full raw metadata as JSON string (stable column type)
+                "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):
+        if self.config.name == "lite":
+            annotations_file = "data/herbench_annotations_lite.json"
+        else:
+            annotations_file = "data/herbench_annotations.json"
+
+        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]]]:
+        with open(annotations_file, encoding="utf-8") as f:
+            annotations = json.load(f)
+
+        for idx, ann in enumerate(annotations):
+            md = ann.get("metadata") or {}
+            if not isinstance(md, dict):
+                # Very defensive: keep schema stable even if a row has unexpected metadata type.
+                md = {"_raw_metadata": md}
+
+            source_dataset = md.get("source_dataset", "unknown")
+            duration = md.get("duration", 0.0)
+            resolution = md.get("resolution", "unknown")
+            evidence_count = md.get("evidence_count", 0)
+            difficulty = md.get("difficulty", "unknown")
+
+            # Normalize numeric types (avoid Arrow type inference issues)
+            try:
+                duration_f = float(duration)
+            except Exception:
+                duration_f = 0.0
+            try:
+                evidence_i = int(evidence_count)
+            except Exception:
+                evidence_i = 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 (ann.get("choices") or [])],
+                "answer": str(ann.get("answer", "")),
+                "answer_index": int(ann.get("answer_index", 0) or 0),
+                "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),
+                "evidence_count": evidence_i,
+                "difficulty": str(difficulty),
+                "metadata_json": json.dumps(md, ensure_ascii=False),
+            }
+
+

herbench_loader.py

@@ -1,333 +0,0 @@
-"""
-HERBench Dataset Loader for Hugging Face
-
-This module provides a Hugging Face datasets loader for HERBench, a benchmark for
-multi-evidence integration in video question answering.
-
-Usage:
-    # Option 1: Load via Hugging Face datasets library
-    from datasets import load_dataset
-    dataset = load_dataset("DanBenAmi/HERBench")
-    print(dataset['test'][0])
-
-    # Option 2: Load locally
-    from datasets import load_dataset
-    dataset = load_dataset("path/to/HERBench/herbench_loader.py")
-
-Example:
-    >>> from datasets import load_dataset
-    >>> dataset = load_dataset("DanBenAmi/HERBench")
-    >>> sample = dataset['test'][0]
-    >>> print(sample['question'])
-    >>> print(sample['choices'])
-    >>> print(sample['answer'])
-
-For more information, visit:
-    - GitHub: https://github.com/DanBenAmi/HERBench
-    - Paper: https://arxiv.org/abs/XXXX.XXXXX (coming soon)
-    - Project Page: https://danbenami.github.io/herbench (coming soon)
-"""
-
-import json
-from pathlib import Path
-from typing import Dict, List, Optional
-
-import datasets
-
-
-_DESCRIPTION = """\
-HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering
-
-HERBench is a challenging benchmark designed to evaluate vision-language models on
-multi-evidence integration in long videos. Unlike existing benchmarks where questions
-can often be answered from single frames, HERBench enforces a High Evidential Requirement
-(ER) where each question requires aggregating at least k ≥ 3 distinct, temporally
-separated visual cues.
-
-Key Features:
-- 27,936 five-way multiple-choice questions (Full) or ~5,600 questions (Lite)
-- 335 unique videos (Full) or ~67 videos (Lite)
-- Average video length of 395 seconds (6.6 minutes)
-- 12 compositional task types covering temporal, spatial, and causal reasoning
-- Mean Minimum Required Frame-Set (MRFS) of 5.49
-- Questions designed to prevent single-frame shortcuts
-- Comprehensive evaluation of multi-evidence reasoning capabilities
-
-Available in two versions:
-- Full: 27,936 questions, 335 videos (~161 GB) - Complete benchmark
-- Lite: ~5,600 questions, ~67 videos (~35 GB) - 20% subset for quick prototyping
-
-The benchmark includes videos from diverse sources:
-- WildTrack: Multi-camera pedestrian tracking scenes
-- HD-EPIC: First-person egocentric videos of daily activities
-- PersonPath22: Person tracking in various environments
-- Movie Trailers: Narrative story understanding
-
-Each question is carefully designed to require:
-1. Multiple pieces of evidence (k ≥ 3 frames)
-2. Temporal separation between evidence frames
-3. Compositional reasoning across evidence
-4. Integration of visual information from different moments
-"""
-
-_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.0"
-
-
-class HERBenchConfig(datasets.BuilderConfig):
-    """BuilderConfig for HERBench."""
-
-    def __init__(self, **kwargs):
-        """BuilderConfig for HERBench.
-
-        Args:
-            **kwargs: keyword arguments forwarded to super.
-        """
-        super(HERBenchConfig, self).__init__(**kwargs)
-
-
-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 with all 27,936 questions and 335 videos (~161GB)",
-        ),
-        HERBenchConfig(
-            name="lite",
-            version=VERSION,
-            description="HERBench-Lite: 20% subset with ~5,600 questions and ~67 videos (~35GB)",
-        ),
-    ]
-
-    DEFAULT_CONFIG_NAME = "full"
-
-    def _info(self):
-        """Specify the datasets.DatasetInfo object."""
-        features = datasets.Features({
-            "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"),
-            "metadata": datasets.Features({
-                "source_dataset": datasets.Value("string"),
-                "duration": datasets.Value("float32"),
-                "resolution": datasets.Value("string"),
-                "evidence_count": datasets.Value("int32"),
-                "difficulty": 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):
-        """Return SplitGenerators."""
-        # Determine which annotation file to use based on config
-        if self.config.name == "lite":
-            annotations_file = "data/herbench_annotations_lite.json"
-        else:
-            annotations_file = "data/herbench_annotations.json"
-        
-        # Download and extract data files
-        data_files = dl_manager.download({
-            "annotations": annotations_file,
-            "task_metadata": "data/task_metadata.json",
-            "video_metadata": "data/video_metadata.json",
-        })
-
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TEST,
-                gen_kwargs={
-                    "annotations_file": data_files["annotations"],
-                    "task_metadata_file": data_files["task_metadata"],
-                    "video_metadata_file": data_files["video_metadata"],
-                },
-            ),
-        ]
-
-    def _generate_examples(self, annotations_file, task_metadata_file, video_metadata_file):
-        """Yield examples as (key, example) tuples."""
-        # Load annotations
-        with open(annotations_file, encoding="utf-8") as f:
-            annotations = json.load(f)
-
-        # Yield each annotation
-        for idx, annotation in enumerate(annotations):
-            # Ensure metadata exists
-            if "metadata" not in annotation:
-                annotation["metadata"] = {
-                    "source_dataset": "unknown",
-                    "duration": 0.0,
-                    "resolution": "unknown",
-                    "evidence_count": 0,
-                    "difficulty": "unknown"
-                }
-            else:
-                # Ensure required metadata fields exist
-                metadata = annotation["metadata"]
-                if "source_dataset" not in metadata:
-                    metadata["source_dataset"] = "unknown"
-                if "duration" not in metadata:
-                    metadata["duration"] = 0.0
-                if "resolution" not in metadata:
-                    metadata["resolution"] = "unknown"
-                if "evidence_count" not in metadata:
-                    metadata["evidence_count"] = 0
-                if "difficulty" not in metadata:
-                    metadata["difficulty"] = "unknown"
-
-            yield idx, {
-                "question_id": annotation.get("question_id", f"HER_{idx:06d}"),
-                "video_id": annotation.get("video_id", ""),
-                "video_path": annotation.get("video_path", ""),
-                "question": annotation.get("question", ""),
-                "choices": annotation.get("choices", []),
-                "answer": annotation.get("answer", ""),
-                "answer_index": int(annotation.get("answer_index", 0)),
-                "answer_text": annotation.get("answer_text", ""),
-                "task_type": annotation.get("task_type", "unknown"),
-                "metadata": annotation["metadata"],
-            }
-
-
-# Example usage and helper functions
-def load_herbench(cache_dir: Optional[str] = None) -> datasets.DatasetDict:
-    """
-    Load HERBench dataset using Hugging Face datasets library.
-
-    Args:
-        cache_dir: Optional directory to cache the dataset.
-
-    Returns:
-        DatasetDict with 'test' split containing all questions.
-
-    Example:
-        >>> dataset = load_herbench()
-        >>> print(f"Total questions: {len(dataset['test'])}")
-        >>> print(dataset['test'][0])
-    """
-    return datasets.load_dataset(
-        "DanBenAmi/HERBench",
-        cache_dir=cache_dir
-    )
-
-
-def get_questions_by_task(dataset, task_type: str) -> List[Dict]:
-    """
-    Filter questions by task type.
-
-    Args:
-        dataset: HERBench dataset or test split.
-        task_type: Task type to filter (e.g., 'temporal_reasoning').
-
-    Returns:
-        List of questions matching the task type.
-
-    Example:
-        >>> dataset = load_herbench()
-        >>> temporal_qs = get_questions_by_task(dataset['test'], 'temporal_reasoning')
-        >>> print(f"Temporal reasoning questions: {len(temporal_qs)}")
-    """
-    if isinstance(dataset, datasets.DatasetDict):
-        dataset = dataset['test']
-
-    return [q for q in dataset if q['task_type'] == task_type]
-
-
-def get_questions_by_video(dataset, video_id: str) -> List[Dict]:
-    """
-    Get all questions for a specific video.
-
-    Args:
-        dataset: HERBench dataset or test split.
-        video_id: Video identifier.
-
-    Returns:
-        List of questions for the specified video.
-
-    Example:
-        >>> dataset = load_herbench()
-        >>> video_qs = get_questions_by_video(dataset['test'], 'cam2_segment_4_180s_240s')
-        >>> print(f"Questions for video: {len(video_qs)}")
-    """
-    if isinstance(dataset, datasets.DatasetDict):
-        dataset = dataset['test']
-
-    return [q for q in dataset if q['video_id'] == video_id]
-
-
-def print_sample(sample: Dict) -> None:
-    """
-    Pretty print a sample from the dataset.
-
-    Args:
-        sample: A single sample from HERBench.
-
-    Example:
-        >>> dataset = load_herbench()
-        >>> print_sample(dataset['test'][0])
-    """
-    duration = sample['metadata'].get('duration', 0.0)
-    print(f"Question ID: {sample['question_id']}")
-    print(f"Video: {sample['video_id']} ({duration:.1f}s)")
-    print(f"Resolution: {sample['metadata'].get('resolution', 'unknown')}")
-    print(f"Task: {sample['task_type']}")
-    print(f"\nQuestion: {sample['question']}")
-    print(f"\nChoices:")
-    for i, choice in enumerate(sample['choices']):
-        marker = "→" if i == sample['answer_index'] else " "
-        print(f"  {marker} {choice}")
-    print(f"\nCorrect Answer: {sample['answer']} (index: {sample['answer_index']})")
-    if sample.get('answer_text'):
-        print(f"Answer Text: {sample['answer_text']}")
-    print(f"Source: {sample['metadata']['source_dataset']}")
-    print("-" * 60)
-
-
-if __name__ == "__main__":
-    # Example usage when run as script
-    print("Loading HERBench dataset...")
-    dataset = load_herbench()
-
-    print(f"\nDataset loaded successfully!")
-    print(f"Total questions: {len(dataset['test'])}")
-
-    print(f"\nFirst sample:")
-    print_sample(dataset['test'][0])
-
-    # Show task distribution
-    from collections import Counter
-    task_counts = Counter(q['task_type'] for q in dataset['test'])
-
-    print(f"\nTask distribution:")
-    for task, count in task_counts.most_common():
-        print(f"  {task}: {count}")