Initial commit: HERBench dataset core files

.gitattributes

@@ -0,0 +1,19 @@
+# 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
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.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

.gitignore

@@ -0,0 +1,50 @@
+# Videos directory (uploaded separately via HF CLI)
+videos/
+
+# Data directory (uploaded separately via HF CLI)
+data/
+
+# Assets directory (uploaded separately via HF CLI)
+assets/
+
+# Scripts directory (not uploaded to HF)
+scripts/
+
+# Build artifacts
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+*.egg
+dist/
+build/
+
+# Temporary files
+*.tmp
+*.temp
+*.swp
+*.swo
+*~
+.DS_Store
+._.DS_Store
+Thumbs.db
+
+# Local video directory (source videos)
+/videos_source/
+
+# Editor directories
+.vscode/
+.idea/
+*.sublime-*
+
+# Local testing
+test_*.py
+scratch/
+
+# Documentation and summary files (not needed in HF repo)
+CHANGES_SUMMARY.md
+FIXES_APPLIED.md
+PROJECT_SUMMARY.md
+QUICK_START.txt
+USAGE_INSTRUCTIONS.md
+upload_videos.sh

CITATION.cff

@@ -0,0 +1,50 @@
+cff-version: 1.2.0
+title: 'HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering'
+message: >-
+  If you use this dataset, please cite it using the metadata from this file.
+type: dataset
+authors:
+  - family-names: Ben-Ami
+    given-names: Dan
+    email: [email protected]
+  - family-names: Serussi
+    given-names: Gabriele
+    email: [email protected]
+  - family-names: Cohen
+    given-names: Kobi
+  - family-names: Baskin
+    given-names: Chaim
+repository-code: 'https://github.com/DanBenAmi/HERBench'
+url: 'https://huggingface.co/datasets/DanBenAmi/HERBench'
+abstract: >-
+  HERBench is a benchmark for evaluating multi-evidence integration in video question answering.
+  It contains 26,806 five-way multiple-choice questions across 337 unique videos with an average
+  length of 395 seconds. Each question enforces a High Evidential Requirement (ER), requiring
+  models to aggregate at least k ≥ 3 distinct, temporally separated visual cues. The benchmark
+  includes 12 compositional task types covering temporal reasoning, spatial reasoning, causal
+  reasoning, counting, comparison, and other multi-evidence challenges.
+keywords:
+  - video understanding
+  - visual question answering
+  - multi-evidence reasoning
+  - temporal reasoning
+  - long video
+  - benchmark
+license: CC-BY-NC-SA-4.0
+date-released: '2025-01-01'
+version: 1.0.0
+preferred-citation:
+  type: article
+  authors:
+    - family-names: Ben-Ami
+      given-names: Dan
+    - family-names: Serussi
+      given-names: Gabriele
+    - family-names: Cohen
+      given-names: Kobi
+    - family-names: Baskin
+      given-names: Chaim
+  title: 'HERBench: A Benchmark for Multi-Evidence Integration in Video Question Answering'
+  year: 2025
+  journal: 'arXiv preprint'
+  notes: 'arXiv:XXXX.XXXXX (to be updated)'

LICENSE

@@ -0,0 +1,63 @@
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree to be bound
+by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike
+4.0 International Public License ("Public License"). To the extent this Public License may
+be interpreted as a contract, You are granted the Licensed Rights in consideration of Your
+acceptance of these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the Licensed Material available
+under these terms and conditions.
+
+Full License Text: https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
+
+===================================================================================================
+
+TERMS OF USE FOR HERBENCH DATASET
+
+Copyright (c) 2025 Dan Ben-Ami, Gabriele Serussi, Kobi Cohen, Chaim Baskin
+
+This dataset is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0
+International License (CC BY-NC-SA 4.0).
+
+You are free to:
+  - Share: copy and redistribute the material in any medium or format
+  - Adapt: remix, transform, and build upon the material
+
+Under the following terms:
+  - Attribution: You must give appropriate credit, provide a link to the license, and indicate
+    if changes were made. You may do so in any reasonable manner, but not in any way that
+    suggests the licensor endorses you or your use.
+
+  - NonCommercial: You may not use the material for commercial purposes.
+
+  - ShareAlike: If you remix, transform, or build upon the material, you must distribute your
+    contributions under the same license as the original.
+
+  - No additional restrictions: You may not apply legal terms or technological measures that
+    legally restrict others from doing anything the license permits.
+
+CITATION:
+If you use this dataset in your research, please cite:
+
+@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}
+}
+
+VIDEO SOURCES:
+The videos in this dataset are sourced from:
+  - WildTrack Dataset (public dataset)
+  - HD-EPIC Dataset (first-person egocentric videos)
+  - PersonPath22 Dataset (person tracking dataset)
+  - Movie Trailers (public promotional content)
+
+All rights to the original videos belong to their respective copyright holders. This dataset
+is provided for academic research purposes only.
+
+CONTACT:
+- Dan Ben-Ami: [email protected]
+- Gabriele Serussi: [email protected]
+
+For more information, visit: https://github.com/DanBenAmi/HERBench

README.md

@@ -0,0 +1,443 @@
+---
+language:
+- en
+license: cc-by-nc-sa-4.0
+task_categories:
+- visual-question-answering
+- multiple-choice
+tags:
+- video-understanding
+- multi-evidence-reasoning
+- long-video
+- temporal-reasoning
+- spatial-reasoning
+- video-qa
+size_categories:
+- 10K<n<100K
+pretty_name: HERBench
+---
+
+# HERBench: Multi-Evidence Integration in Video Question Answering
+
+<div align="center">
+
+<img src="assets/HERBench_logo.png" alt="HERBench Logo" width="400"/>
+
+[![Paper](https://img.shields.io/badge/arXiv-XXXX.XXXXX-b31b1b.svg)](https://arxiv.org/abs/XXXX.XXXXX)
+[![GitHub](https://img.shields.io/badge/GitHub-HERBench-181717?logo=github)](https://github.com/DanBenAmi/HERBench)
+[![Project Page](https://img.shields.io/badge/Project-Page-blue)](https://danbenami.github.io/herbench)
+[![License](https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-nc-sa/4.0/)
+[![HF Dataset](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Dataset-yellow)](https://huggingface.co/datasets/DanBenAmi/HERBench)
+
+*A challenging benchmark for evaluating multi-evidence integration capabilities of vision-language models*
+
+</div>
+
+---
+
+## 📋 Dataset Summary
+
+**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**.
+
+<div align="center">
+<img src="assets/Teaser_plot.jpg" alt="HERBench Teaser" width="800"/>
+</div>
+
+### Key Statistics
+
+| Metric | Full Version | Lite Version |
+|--------|--------------|--------------|
+| 📊 **Total Questions** | 27,936 five-way multiple-choice | ~5,600 questions (20%) |
+| 🎬 **Videos** | 335 unique videos | ~67 videos (20%) |
+| ⏱️ **Avg. Video Length** | 395 seconds (6.6 minutes) ||
+| 📈 **Mean MRFS (Minimum Required Frame-Set)** | ~5.5 ||
+| 📁 **Total Size** | ~161 GB | ~35 GB |
+
+### Why HERBench?
+
+Current video QA benchmarks often allow models to answer questions using single frames or limited context, failing to test true multi-evidence reasoning. HERBench addresses this by:
+
+✅ **Enforcing multi-evidence integration** - Each question requires k ≥ 3 temporally separated frames  
+✅ **Preventing single-frame shortcuts** - Questions cannot be answered from isolated frames  
+✅ **Testing compositional reasoning** - Combines temporal, spatial, and causal reasoning  
+✅ **Evaluating long-video understanding** - Average video length of 6.6 minutes
+
+### 🎯 Choose Your Version
+
+HERBench is available in two versions to accommodate different storage and computational constraints:
+
+#### Full Version (~161 GB)
+- **27,936 questions** across **335 videos**
+- Complete benchmark for comprehensive evaluation
+- Recommended for: Final paper results, thorough model evaluation, benchmarking
+
+#### Lite Version (~35 GB) 🚀
+- **~5,600 questions** across **~67 videos** (20% subset)
+- Same task distribution and difficulty as full version
+- Videos sampled to maintain diversity across all 12 tasks
+- Recommended for: Quick prototyping, limited storage, initial experiments, development
+
+**Both versions maintain the same quality standards and high evidential requirements!**
+
+---
+
+## 📊 Leaderboard
+
+Current state-of-the-art results on HERBench (Full benchmark):
+
+| Model | Bench Version | # Frames | TR&C | R&T | GC&V | ME&N | Overall Avg. |
+|-------|---------------|----------|------|-----|------|------|--------------|
+| **Random Baseline** | Full | 16 | 20.0 | 20.0 | 20.0 | 20.0 | **20.0** |
+| **GPT-4.1** | Full | 16 | 25.4 | 66.0 | 37.1 | 29.0 | **39.4** |
+| **Gemini-2.5-Flash** | Full | 16 | 29.7 | 69.9 | 34.9 | 26.8 | **40.3** |
+| **Qwen2.5-VL-72B** | Full | 16 | 26.9 | 70.9 | 36.6 | 24.4 | **39.7** |
+| **Gemma-3-27B** | Full | 16 | 32.0 | 58.4 | 21.5 | 23.5 | **33.8** |
+| **LLaMA-4-Scout-17B** | Full | 16 | 18.8 | 57.3 | 25.5 | 24.2 | **31.4** |
+| **InternVL3.5-14B** | Full | 16 | 37.7 | 69.3 | 31.1 | 27.8 | **41.5** |
+| **Ovis-2.5-9B** | Full | 16 | 18.9 | 73.5 | 46.8 | 29.2 | **42.1** |
+| **InternVL3.5-8B** | Full | 16 | 33.6 | 70.2 | 29.7 | 30.8 | **41.1** |
+| **LLaVA-OneVision1.5-8B** | Full | 16 | 26.1 | 67.7 | 33.6 | 24.9 | **38.1** |
+| **Qwen3-VL-8B** | Full | 16 | 19.0 | 68.7 | 40.6 | 25.2 | **38.3** |
+| **MiniCPM-V4.5-8B** | Full | 16 | 23.8 | 71.1 | 39.7 | 24.9 | **39.9** |
+| **Qwen2.5-VL-7B** | Full | 16 | 21.8 | 60.6 | 38.7 | 22.6 | **35.9** |
+| **LLaVA-OneVision-7B** | Full | 16 | 27.3 | 59.1 | 30.1 | 26.0 | **35.6** |
+
+*TR&C = Temporal Reasoning & Chronology, R&T = Referring & Tracking, GC&V = Global Consistency & Verification, ME&N = Multi-Entity Aggregation & Numeracy*
+
+**Key Findings:**
+
+- 🔍 **Referring & Tracking is easier**: Models perform best on R&T tasks (avg. 66.8%) compared to other categories
+- 🧩 **Multi-evidence is challenging**: Overall accuracy of 38.2% shows substantial room for improvement
+- 📏 **Top performers**: Ovis-2.5-9B (42.1%) and InternVL3.5-14B (41.5%) lead the benchmark
+- ⚖️ **Task variance**: Performance varies significantly across task families, with GC&V and ME&N being most challenging
+
+---
+
+## 🎯 Dataset Features
+
+### High Evidential Requirement (ER)
+
+Each question in HERBench is designed to require:
+
+1. **Multiple evidence pieces** (k ≥ 3 frames minimum)
+2. **Temporal separation** between evidence frames
+3. **Compositional reasoning** across evidence
+4. **Integration** of visual information from different moments
+
+### 12 Compositional Task Types
+
+#### Temporal Reasoning & Chronology
+
+| Task Name | Abilities Tested | Example |
+|-----------|------------------|---------|
+| **[TSO] Temporal Shot Ordering** | Understanding event order, high-level scene transitions, chronological reconstruction using content cues | "The following 4 shots take place in the video: [Shot 1-4 descriptions]. Select the option that correctly reflects the order in which these shots occur in the video." |
+| **[MPDR] Multi-Person Duration Reasoning** | Fine-grained time-span contrasts, interval statistics, comparing appearance durations across individuals | "These people were in the video: [Person 1-3 descriptions]. Who stayed in the frame FOV for the longest time?" |
+| **[ASII] Action Sequence Integrity & Identification** | Micro-level task sequencing, action ordering, temporal understanding of fine-grained activities | "What is the correct temporal order of the 5 narrated events? (e.g., 1. slide coffee capsule -> 2. close lid -> 3. turn off processor -> 4. place orange -> 5. put down sponge)" |
+
+#### Referring & Tracking
+
+| Task Name | Abilities Tested | Example |
+|-----------|------------------|---------|
+| **[AGBI] Appearance-Grounded Behavior Interactions** | Social and relational cues, identity maintenance across time, interaction recognition | "In the video there is exactly one individual that fits the following description: [Appearance]. Who is accompanying the person as they walk across the frame?" |
+| **[AGAR] Appearance-Grounded Attribute Recognition** | Moment-specific attribute extraction, target tracking, reading contextual details from specific individuals | "In the video there is exactly one individual that fits the following description: [Appearance]. What color is the jacket worn by the individual who remains seated as the main subject walks past?" |
+| **[AGLT] Appearance-Grounded Localization Trajectory** | Global path-level motion reasoning, trajectory tracking, spatial exit/entry point identification | "In the video there is exactly one individual that fits the following description: [Appearance]. How does the person exit the frame at the end of their path?" |
+
+#### Global Consistency & Verification
+
+| Task Name | Abilities Tested | Example |
+|-----------|------------------|---------|
+| **[FAM] False Action Memory** | Action-level absence detection, exhaustive video-wide verification, distinguishing what did not occur | "Which of the following actions did NOT occur in the video? (A) open drawer (B) open up fridge (C) turn on tap..." |
+| **[SVA] Scene Verification Arrangement** | Shot-level fidelity checking, chronology verification, distinguishing real from fabricated descriptions | "From the correctly described shots, which is the one that appears first in the video? [Multiple shot descriptions provided]" |
+| **[FOM] False Object Memory** | Object-level absence detection, interaction verification, identifying non-interacted objects | "Which object did the camera wearer NOT interact with? (A) Cutting board (B) Sponge (C) Dish soap (D) Garlic presser..." |
+
+#### Multi-Entity Aggregation & Numeracy
+
+| Task Name | Abilities Tested | Example |
+|-----------|------------------|---------|
+| **[MEGL] Multi-Entities Grounding & Localization** | Set membership verification, identity deduplication, exact-match appearance verification | "Which of the following people appeared in the video (the person description must match exactly): [Person 1-3 descriptions] - A) only 1 and 3" |
+| **[AC] Action Counting** | Event-accumulation across dispersed moments, counting repeated actions, temporal aggregation | "How many times does the action-object pair 'close tap' occur? A) 3  B) 5  C) 7..." |
+| **[RLPC] Region-Localized People Counting** | Region-conditioned identity aggregation, spatial partitioning, counting with spatial constraints | "How many people entered the frame through the top edge? Select the range that includes the correct count." |
+
+### Video Sources
+
+Videos are sourced from diverse, high-quality datasets:
+
+- **WildTrack** (56 segments): Multi-camera pedestrian tracking scenes
+- **HD-EPIC** (176 videos): First-person egocentric daily activities
+- **PersonPath22** (24 videos): Person tracking scenarios
+- **Movie Trailers** (81 videos): Narrative storytelling content
+
+---
+
+## 📥 Dataset Structure
+
+```
+HERBench/
+├── data/
+│   ├── herbench_annotations.json        # Full: 27,936 questions
+│   ├── herbench_annotations_lite.json   # Lite: ~5,600 questions
+│   ├── task_metadata.json               # Task descriptions (shared)
+│   ├── video_metadata.json              # Video information (shared)
+│   └── README_DATA.md                   # Data format documentation
+├── videos/
+│   ├── videos.tar.part.00               # Lite videos start here
+│   ├── videos.tar.part.01               # |
+│   ├── videos.tar.part.02               # | Lite: parts 00-03 (~35GB)
+│   ├── videos.tar.part.03               # |
+│   ├── videos.tar.part.04               # |
+│   ├── ...                              # | Full: all parts 00-XX (~161GB)
+│   ├── 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)
+```
+
+**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.
+
+---
+
+### Annotation Format
+
+Each sample contains:
+
+```json
+{
+  "question_id": "HER_001234",
+  "video_id": "cam2_segment_4_180s_240s",
+  "video_path": "videos/WildTrack/cam2_segment_4_180s_240s.mp4",
+  "question": "What is the main activity happening throughout the video?",
+  "choices": [
+    "A. People walking across the scene",
+    "B. People standing and talking",
+    "C. People running in the same direction",
+    "D. People sitting on benches",
+    "E. People cycling through the area"
+  ],
+  "answer": "A",
+  "answer_index": 0,
+  "answer_text": "People walking across the scene",
+  "task_type": "activity_recognition",
+  "metadata": {
+    "source_dataset": "WildTrack",
+    "duration": 60.0,
+    "resolution": "1920x1080",
+    "difficulty": "medium"
+  }
+}
+```
+
+For detailed format documentation, see [data/README_DATA.md](data/README_DATA.md).
+
+---
+
+## 🚀 Quick Start
+
+### 1. Download the Dataset
+
+#### Option A: Using Hugging Face CLI (Recommended)
+
+```bash
+# Install Hugging Face CLI
+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)
+huggingface-cli download DanBenAmi/HERBench \
+    --include "data/herbench_annotations_lite.json" \
+    --include "data/*metadata.json" \
+    --include "videos/videos.tar.part.00" \
+    --include "videos/videos.tar.part.01" \
+    --include "videos/videos.tar.part.02" \
+    --include "videos/videos.tar.part.03" \
+    --include "videos/videos_lite_info.txt" \
+    --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
+```
+
+#### Option B: Using Python
+
+```python
+from datasets import load_dataset
+
+# Load FULL version (default)
+dataset_full = load_dataset("DanBenAmi/HERBench", name="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'])}")
+```
+
+### 2. Extract Videos
+
+#### For Full Version:
+
+```bash
+cd HERBench/videos
+
+# Concatenate all split archives
+cat videos.tar.part.* > videos_full.tar
+
+# Extract videos
+tar -xvf videos_full.tar
+
+# Verify checksums (optional)
+sha256sum -c videos.tar.checksums.txt
+
+# Clean up tar file (optional)
+rm videos_full.tar
+```
+
+#### For Lite Version:
+
+```bash
+cd HERBench/videos
+
+# Concatenate only lite archives (parts 00-03)
+cat videos.tar.part.{00..03} > videos_lite.tar
+
+# Extract videos
+tar -xvf videos_lite.tar
+
+# Clean up tar file (optional)
+rm videos_lite.tar
+```
+
+> **Note:** The archive is structured so lite videos are in the first parts (00-03). This means if you download the full version, you automatically have the lite videos too!
+
+### 3. Load and Use the Data
+
+```python
+from datasets import load_dataset
+
+# Load the dataset (choose version)
+dataset = load_dataset("DanBenAmi/HERBench", name="full")  # or name="lite"
+
+# Access a sample
+sample = dataset['test'][0]
+print(f"Question: {sample['question']}")
+print(f"Choices: {sample['choices']}")
+print(f"Answer: {sample['answer']}")
+print(f"Video: {sample['video_path']}")
+print(f"Task: {sample['task_type']}")
+
+# Filter by task type
+temporal_questions = [
+    q for q in dataset['test']
+    if q['task_type'] == 'temporal_reasoning'
+]
+print(f"Temporal reasoning questions: {len(temporal_questions)}")
+
+# Compare versions
+dataset_full = load_dataset("DanBenAmi/HERBench", name="full")
+dataset_lite = load_dataset("DanBenAmi/HERBench", name="lite")
+print(f"Full: {len(dataset_full['test'])} questions")
+print(f"Lite: {len(dataset_lite['test'])} questions")
+```
+
+### 4. Run Evaluation
+
+```bash
+# Clone the evaluation code
+git clone https://github.com/DanBenAmi/HERBench.git
+cd HERBench
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run evaluation on your model
+python evaluation/run_evaluation.py \
+    model=your_model \
+    data_path=./HERBench \
+    output_path=./results
+```
+
+
+---
+
+## 📜 Citation
+
+If you use HERBench in your research, please cite:
+
+```bibtex
+@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}
+}
+```
+
+---
+
+## 📄 License
+
+This dataset is released under the [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-nc-sa/4.0/).
+
+### Terms of Use
+
+**Research Use Only.**  
+HERBench is released strictly for non-commercial research and educational purposes.  
+The benchmark is constructed using videos originating from existing datasets and platforms, including WildTrack, HD-EPIC, PersonPath22, and publicly available online videos (e.g., YouTube trailers). All rights to the original video content remain with their respective owners and licensors.
+
+HERBench does not claim ownership of any underlying video content. The use of such materials is intended solely for academic evaluation and analysis, in accordance with the terms of the respective source datasets and platforms.
+
+**Removal upon request.**  
+If any content owner or rights holder believes that their material has been included in HERBench in a manner that violates applicable terms or rights, please contact us. Upon notification, we will promptly investigate the request and remove the relevant content as appropriate.
+
+---
+
+## 🙏 Acknowledgments
+
+We thank the creators of the original video datasets (WildTrack, HD-EPIC, PersonPath22) for making their data publicly available. We also acknowledge the movie studios for releasing promotional trailers.
+
+This work was supported by [Institution/Grant acknowledgments to be added].
+
+---
+
+## 📧 Contact
+
+### Authors
+
+- **Dan Ben-Ami** - [email protected]
+- **Gabriele Serussi** - [email protected]
+- **Kobi Cohen**
+- **Chaim Baskin**
+
+### Support
+
+- **Issues**: [GitHub Issues](https://github.com/DanBenAmi/HERBench/issues)
+- **Discussions**: [HF Discussions](https://huggingface.co/datasets/DanBenAmi/HERBench/discussions)
+- **Email**: [email protected]
+
+---
+
+## 🔄 Updates
+
+- **v1.0.0** (January 2025): Initial release with 27,936 questions across 335 videos
+
+
+---
+
+## 🔗 Links
+
+- 📄 **Paper**: https://arxiv.org/abs/XXXX.XXXXX *(coming soon)*
+- 💻 **Code**: https://github.com/DanBenAmi/HERBench
+- 🌐 **Project Page**: https://danbenami.github.io/herbench *(coming soon)*
+- 🤗 **Dataset**: https://huggingface.co/datasets/DanBenAmi/HERBench
+- 📊 **Leaderboard**: *(coming soon)*
+
+---
+
+<div align="center">
+
+**Built with ❤️ for advancing video understanding research**
+
+*If you find HERBench useful, please ⭐ star our [GitHub repository](https://github.com/DanBenAmi/HERBench)!*
+
+</div>

herbench_loader.py

@@ -0,0 +1,333 @@
+"""
+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}")