Add files using upload-large-folder tool

README.md

@@ -1,5 +1,87 @@
 ---
-license: cc-by-nc-sa-4.0
+license: unknown
 task_categories:
-- question-answering
----
+- video-text-to-text
+configs:
+  - config_name: default
+    data_files:
+      - split: full
+        path: data/all.parquet
+      - split: test
+        path: data/test.parquet
+---
+
+# CUVA
+
+## Repository Layout
+
+```text
+data/
+  all.parquet
+  test.parquet
+raw/
+  cuva_gt_cleaned.json
+  cuva_test.json
+  cuva_test_filled.json
+  group_0.zip
+  group_1.zip
+  group_2.zip
+  group_3.zip
+scripts/
+  build_hf_repo.py
+  fill_cuva_test.py
+```
+
+## Split Layout
+
+Splits:
+
+- `full`: backed by `data/all.parquet`, which contains `raw/cuva_gt_cleaned.json` + `raw/cuva_test_filled.json`
+- `test`: `raw/cuva_test_filled.json`
+
+Columns:
+
+- `instruction`
+- `visual_input`
+- `output`
+- `task`
+- `ID`
+
+## Build
+
+```bash
+python scripts/fill_cuva_test.py --repo-root .
+python scripts/build_hf_repo.py --repo-root .
+```
+
+The build script moves the original JSON and zip files into `raw/` if they are still in the repository root, then writes `data/all.parquet` and `data/test.parquet`.
+
+## Load from Hugging Face Hub
+
+```python
+from datasets import load_dataset
+
+all_ds = load_dataset("your-name/CUVA", split="full")
+test_ds = load_dataset("your-name/CUVA", split="test")
+```
+
+## Load from Local Files
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset(
+    "parquet",
+    data_files={
+        "full": "data/all.parquet",
+        "test": "data/test.parquet",
+    },
+)
+```
+
+## Notes
+
+- The parquet files preserve the original column names.
+- The raw source files remain in `raw/` without renaming.
+- Because `output` and `ID` are mixed-type in the original JSON files, the parquet export stores them as strings so both splits share one stable schema.
+- `all.parquet` keeps the requested filename, but Hugging Face `datasets` reserves `all` as a special keyword, so the loadable split name must be `full` rather than `all`.

data/all.parquet

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

data/test.parquet

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

raw/group_0.zip

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

raw/group_1.zip

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

raw/group_2.zip

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

raw/group_3.zip

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

scripts/build_hf_repo.py

@@ -0,0 +1,96 @@
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+RAW_JSON_FILES = [
+    "cuva_gt_cleaned.json",
+    "cuva_test.json",
+    "cuva_test_filled.json",
+]
+
+VIDEO_ARCHIVES = [
+    "group_0.zip",
+    "group_1.zip",
+    "group_2.zip",
+    "group_3.zip",
+]
+
+PARQUET_COLUMNS = ["instruction", "visual_input", "output", "task", "ID"]
+
+
+def load_json(path: Path):
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def move_raw_files(repo_root: Path, raw_dir: Path) -> None:
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    for filename in RAW_JSON_FILES + VIDEO_ARCHIVES:
+        src = repo_root / filename
+        dst = raw_dir / filename
+        if src.exists() and not dst.exists():
+            shutil.move(str(src), str(dst))
+
+
+def normalize_rows(rows):
+    normalized = []
+    for row in rows:
+        normalized.append(
+            {
+                "instruction": row["instruction"],
+                "visual_input": row["visual_input"],
+                "output": str(row["output"]),
+                "task": row["task"],
+                "ID": str(row["ID"]),
+            }
+        )
+    return normalized
+
+
+def write_parquet(rows, output_path: Path) -> None:
+    df = pd.DataFrame(normalize_rows(rows), columns=PARQUET_COLUMNS)
+    schema = pa.schema(
+        [
+            ("instruction", pa.string()),
+            ("visual_input", pa.string()),
+            ("output", pa.string()),
+            ("task", pa.string()),
+            ("ID", pa.string()),
+        ]
+    )
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pandas(df, schema=schema, preserve_index=False)
+    pq.write_table(table, output_path)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build a HF-style CUVA dataset repo with raw files and parquet splits.")
+    parser.add_argument("--repo-root", type=Path, default=Path(__file__).resolve().parent.parent)
+    args = parser.parse_args()
+
+    repo_root = args.repo_root.resolve()
+    raw_dir = repo_root / "raw"
+    data_dir = repo_root / "data"
+
+    move_raw_files(repo_root, raw_dir)
+
+    gt_rows = load_json(raw_dir / "cuva_gt_cleaned.json")
+    test_rows = load_json(raw_dir / "cuva_test_filled.json")
+    all_rows = gt_rows + test_rows
+
+    write_parquet(test_rows, data_dir / "test.parquet")
+    write_parquet(all_rows, data_dir / "all.parquet")
+
+    print(f"Built parquet splits under: {data_dir}")
+    print(f"test rows: {len(test_rows)}")
+    print(f"all rows: {len(all_rows)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/fill_cuva_test.py

@@ -0,0 +1,101 @@
+import argparse
+import json
+from pathlib import Path
+
+
+DETECTION_INSTRUCTION = (
+    "Determine whether the video contains an anomalous event. "
+    "Output 1 if an anomaly is present."
+)
+
+EXPECTED_TEST_TASKS = {
+    "Classification",
+    "Cause",
+    "Result",
+    "Timestamp",
+    "Description",
+    "Detection",
+}
+
+
+def load_json(path: Path):
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def dump_json(path: Path, data) -> None:
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+        f.write("\n")
+
+
+def build_instruction_map(gt_rows):
+    task_to_instruction = {}
+    for row in gt_rows:
+        task = row["task"]
+        instruction = row["instruction"]
+        existing = task_to_instruction.get(task)
+        if existing is None:
+            task_to_instruction[task] = instruction
+        elif existing != instruction:
+            raise ValueError(f"Task {task!r} has multiple instructions in gt")
+    return task_to_instruction
+
+
+def fill_test_rows(test_rows, task_to_instruction):
+    filled = []
+    for row in test_rows:
+        task = row["task"]
+        if task == "Detection":
+            instruction = DETECTION_INSTRUCTION
+        else:
+            if task not in task_to_instruction:
+                raise KeyError(f"Missing instruction mapping for task {task!r}")
+            instruction = task_to_instruction[task]
+
+        filled.append(
+            {
+                "instruction": instruction,
+                "visual_input": row["visual_input"],
+                "output": row["output"],
+                "task": row["task"],
+                "ID": row["ID"],
+            }
+        )
+    return filled
+
+
+def resolve_data_dir(repo_root: Path) -> Path:
+    raw_dir = repo_root / "raw"
+    return raw_dir if raw_dir.exists() else repo_root
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fill missing instructions in CUVA test annotations.")
+    parser.add_argument("--repo-root", type=Path, default=Path(__file__).resolve().parent.parent)
+    args = parser.parse_args()
+
+    repo_root = args.repo_root.resolve()
+    data_dir = resolve_data_dir(repo_root)
+
+    gt_path = data_dir / "cuva_gt_cleaned.json"
+    test_path = data_dir / "cuva_test.json"
+    output_path = data_dir / "cuva_test_filled.json"
+
+    gt_rows = load_json(gt_path)
+    test_rows = load_json(test_path)
+
+    task_to_instruction = build_instruction_map(gt_rows)
+    test_tasks = {row["task"] for row in test_rows}
+    unknown_tasks = test_tasks - EXPECTED_TEST_TASKS
+    if unknown_tasks:
+        raise ValueError(f"Unexpected tasks in test set: {sorted(unknown_tasks)}")
+
+    filled_rows = fill_test_rows(test_rows, task_to_instruction)
+    dump_json(output_path, filled_rows)
+
+    print(f"Wrote {len(filled_rows)} rows to {output_path}")
+
+
+if __name__ == "__main__":
+    main()