Datasets:

DanBenAmi
/

HERBench

	"""
	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),
	}