Update FunQA dataset repo

.gitattributes

@@ -56,3 +56,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 Funqa_mcqa_v1.json filter=lfs diff=lfs merge=lfs -text
 FunQA_train.json filter=lfs diff=lfs merge=lfs -text
 FunQA_val.json filter=lfs diff=lfs merge=lfs -text
+raw/Funqa_mcqa_v1.json filter=lfs diff=lfs merge=lfs -text
+raw/FunQA_train.json filter=lfs diff=lfs merge=lfs -text
+raw/FunQA_val.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+scripts/__pycache__/
+hf_ready/

README.md

@@ -2,8 +2,173 @@
 license: cc-by-nc-sa-4.0
 task_categories:
 - video-text-to-text
+configs:
+  - config_name: standard
+    data_files:
+      - split: train
+        path: data/train.parquet
+      - split: validation
+        path: data/validation.parquet
+      - split: test
+        path: data/test.parquet
+  - config_name: mcqa
+    data_files:
+      - split: mcqa_test
+        path: data/mcqa_test.parquet
 ---
 
 # Dataset for the paper: FunQA: Towards Surprising Video Comprehension
 
-Paper: https://huggingface.co/papers/2306.14899.
+Paper: https://huggingface.co/papers/2306.14899.
+
+## Repository Layout
+
+```text
+data/
+  train.parquet
+  validation.parquet
+  test.parquet
+  mcqa_test.parquet
+videos/
+  train/
+    train_humor/
+    train_magic/
+    train_creative/
+  validation/
+    val_humor/
+    val_magic/
+    val_creative/
+  test/
+    test_humor/
+    test_magic/
+    test_creative/
+raw/
+  FunQA_train.json
+  FunQA_val.json
+  FunQA_test.json
+  Funqa_mcqa_v1.json
+  train.zip
+  val.zip
+  test.zip
+```
+
+## Dataset Configs
+
+### `standard`
+
+Splits:
+
+- `train`
+- `validation`
+- `test`
+
+Columns:
+
+- `instruction`
+- `visual_input`
+- `output`
+- `task`
+
+### `mcqa`
+
+Splits:
+
+- `mcqa_test`
+
+Columns:
+
+- `instruction`
+- `visual_input`
+- `gt`
+- `id`
+
+## Load from Hugging Face Hub
+
+```python
+from datasets import load_dataset
+
+train_ds = load_dataset("your-name/FunQA", "standard", split="train")
+val_ds = load_dataset("your-name/FunQA", "standard", split="validation")
+test_ds = load_dataset("your-name/FunQA", "standard", split="test")
+mcqa_ds = load_dataset("your-name/FunQA", "mcqa", split="mcqa_test")
+```
+
+`load_dataset(...)` loads and caches the annotation files used by the selected config/split. It does not automatically download unrelated archive files in the repository.
+
+## Load from Local Files
+
+```python
+from datasets import load_dataset
+
+standard_ds = load_dataset(
+    "parquet",
+    data_files={
+        "train": "data/train.parquet",
+        "validation": "data/validation.parquet",
+        "test": "data/test.parquet",
+    },
+)
+
+mcqa_ds = load_dataset(
+    "parquet",
+    data_files={"mcqa_test": "data/mcqa_test.parquet"},
+)
+```
+
+## Download Video Archives
+
+If you want the original video files, download the split archives explicitly from the dataset repository.
+
+Download one archive into the Hugging Face cache:
+
+```python
+from huggingface_hub import hf_hub_download
+
+zip_path = hf_hub_download(
+    repo_id="your-name/FunQA",
+    repo_type="dataset",
+    filename="raw/test.zip",
+)
+print(zip_path)
+```
+
+Download the whole repository snapshot:
+
+```python
+from huggingface_hub import snapshot_download
+
+repo_dir = snapshot_download(
+    repo_id="your-name/FunQA",
+    repo_type="dataset",
+)
+print(repo_dir)
+```
+
+If needed, download files to a specific local folder instead of only using the default cache:
+
+```python
+from huggingface_hub import snapshot_download
+
+repo_dir = snapshot_download(
+    repo_id="your-name/FunQA",
+    repo_type="dataset",
+    local_dir="funqa_local",
+)
+```
+
+After extracting the archives, locate a video by combining the split directory with `visual_input`:
+
+```python
+from pathlib import Path
+
+sample = test_ds[0]
+video_name = sample["visual_input"]
+video_path = next(Path("videos/test").rglob(video_name))
+print(video_path)
+```
+
+## Notes
+
+- The parquet files preserve the original JSON field names.
+- `standard` and `mcqa` are separated into different configs because they use different schemas.
+- The video archives are stored as repository files and should be downloaded explicitly with `huggingface_hub` if you need the raw videos.

data/mcqa_test.parquet

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

data/test.parquet

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

data/train.parquet

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

data/validation.parquet

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

raw/FunQA_train.json

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

raw/FunQA_val.json

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

raw/Funqa_mcqa_v1.json

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

raw/test.zip

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

raw/train.zip

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

raw/val.zip

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

scripts/build_hf_repo.py

@@ -0,0 +1,137 @@
+import argparse
+import json
+import shutil
+import zipfile
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+RAW_FILES = {
+    "train": "FunQA_train.json",
+    "validation": "FunQA_val.json",
+    "test": "FunQA_test.json",
+    "mcqa_test": "Funqa_mcqa_v1.json",
+}
+
+VIDEO_ARCHIVES = {
+    "validation": "val.zip",
+    "test": "test.zip",
+    "train": "train.zip",
+}
+
+
+def load_raw_rows(raw_dir: Path, split: str):
+    with (raw_dir / RAW_FILES[split]).open("r", encoding="utf-8") as f:
+        rows = json.load(f)
+    if split == "validation":
+        missing_videos = {"C_KT_6_6347_6427.mp4"}
+        rows = [row for row in rows if row.get("visual_input") not in missing_videos]
+    return rows
+
+
+def write_parquet(rows, output_path: Path):
+    df = pd.DataFrame(rows)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if "output" in df.columns:
+        schema = pa.schema(
+            [
+                ("instruction", pa.string()),
+                ("visual_input", pa.string()),
+                ("output", pa.string()),
+                ("task", pa.string()),
+            ]
+        )
+        df = df[["instruction", "visual_input", "output", "task"]]
+    else:
+        schema = pa.schema(
+            [
+                ("instruction", pa.string()),
+                ("visual_input", pa.string()),
+                ("gt", pa.string()),
+                ("id", pa.string()),
+            ]
+        )
+        df = df[["instruction", "visual_input", "gt", "id"]]
+
+    table = pa.Table.from_pandas(df, schema=schema, preserve_index=False)
+    pq.write_table(table, output_path)
+
+
+def move_raw_files(repo_root: Path, raw_dir: Path):
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    for filename in list(RAW_FILES.values()) + list(VIDEO_ARCHIVES.values()):
+        src = repo_root / filename
+        dst = raw_dir / filename
+        if src.exists() and not dst.exists():
+            shutil.move(str(src), str(dst))
+
+
+def extract_split_videos(raw_dir: Path, videos_dir: Path, split: str):
+    archive_name = VIDEO_ARCHIVES[split]
+    archive_path = raw_dir / archive_name
+    if not archive_path.exists():
+        return
+    videos_dir.mkdir(parents=True, exist_ok=True)
+    marker = videos_dir / f".{split}_extracted"
+    if marker.exists():
+        return
+    with zipfile.ZipFile(archive_path) as zf:
+        zf.extractall(videos_dir)
+    marker.write_text("ok\n", encoding="utf-8")
+
+
+def normalize_video_layout(videos_dir: Path, split: str):
+    alias = {"validation": "val"}.get(split, split)
+    alias_root = videos_dir / alias
+    expected_root = videos_dir / split
+    if alias_root.exists() and alias_root != expected_root and not expected_root.exists():
+        shutil.move(str(alias_root), str(expected_root))
+
+    legacy_root = videos_dir / split / split
+    if legacy_root.exists():
+        expected_root.mkdir(parents=True, exist_ok=True)
+        for child in legacy_root.iterdir():
+            target = expected_root / child.name
+            if not target.exists():
+                shutil.move(str(child), str(target))
+
+    legacy_alias_root = videos_dir / split / alias
+    if legacy_alias_root.exists():
+        expected_root.mkdir(parents=True, exist_ok=True)
+        for child in legacy_alias_root.iterdir():
+            target = expected_root / child.name
+            if not target.exists():
+                shutil.move(str(child), str(target))
+
+
+def ensure_layout(repo_root: Path):
+    move_raw_files(repo_root, repo_root / "raw")
+    for split in ["test", "validation", "train"]:
+        extract_split_videos(repo_root / "raw", repo_root / "videos", split)
+        normalize_video_layout(repo_root / "videos", split)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build a HF Hub-style FunQA dataset repo with original columns.")
+    parser.add_argument("--repo-root", type=Path, default=Path("."))
+    args = parser.parse_args()
+
+    repo_root = args.repo_root.resolve()
+    ensure_layout(repo_root)
+
+    raw_dir = repo_root / "raw"
+    data_dir = repo_root / "data"
+
+    for split in RAW_FILES:
+        rows = load_raw_rows(raw_dir, split)
+        write_parquet(rows, data_dir / f"{split}.parquet")
+
+    print(f"Built parquet splits under: {data_dir}")
+
+
+if __name__ == "__main__":
+    main()