Add files using upload-large-folder tool

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+metadata.parquet filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,61 @@
+---
+dataset_info:
+  features:
+  - name: text
+    dtype: string
+  - name: video
+    dtype: string
+  - name: hard_negative_texts
+    list: string
+  - name: hard_negative_videos
+    list: string
+  splits:
+  - name: train
+    num_bytes: 264777020
+    num_examples: 700
+  download_size: 264777020
+  dataset_size: 264777020
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: metadata.parquet
+---
+
+# Physics Bench Fluid Train
+
+Repository: `gowitheflowlab/physics-bench-fluid-train`
+
+Training split with hard negatives for fluid simulation video retrieval.
+
+- rows: 700
+- metadata columns: `text`, `video`, `hard_negative_texts`, `hard_negative_videos`
+- hard negatives per row: 5, drawn from the other 99 cases of the same family
+- video paths: repository-relative `videos/<family>/<case_id>.mp4`
+- list alignment: `hard_negative_texts[i]` and `hard_negative_videos[i]` come from the same case
+- `text` and `hard_negative_texts` use the natural-language query style (`fluid_eval_queries_v2_dynamics_aligned_raw_parsed`),
+  matching the `parsed_text` column of `gowitheflowlab/physics-bench-fluid-eval-700`
+- case parameters are disjoint from the evaluation split, so no evaluation case is reachable here
+
+## Reproducibility
+
+- sampling: global seed 42, family alphabetical order then case_id order, one
+  `random.Random(seed)` stream, `random.sample(sorted(other_99_case_ids), 5)`
+- assignment digest: `0ff52088ba29da60`
+- text: generated from the training case metadata; see
+  `source_metadata/build_hardnegs_v2_metadata.py` and `source_metadata/v2_manifest.json`
+- validation report: `quality/validation.json`
+
+## Loading
+
+```python
+from pathlib import Path
+import pyarrow.parquet as pq
+from huggingface_hub import snapshot_download
+
+root = Path(snapshot_download("gowitheflowlab/physics-bench-fluid-train", repo_type="dataset"))
+rows = pq.read_table(root / "metadata.parquet").to_pylist()
+row = rows[0]
+positive_video = root / row["video"]
+negative_videos = [root / path for path in row["hard_negative_videos"]]
+```

generation_manifest.json

@@ -0,0 +1,16 @@
+{
+  "repo_id": "gowitheflowlab/physics-bench-fluid-train",
+  "source_repo": "gowitheflowlab/physics-bench-fluid-train-700",
+  "seed": 42,
+  "algorithm": "one random.Random(seed) stream; sorted high-level families; sorted case_id; random.sample(sorted(other_99_case_ids), 5)",
+  "family_count": 7,
+  "total_rows": 700,
+  "assignment_sha256": "4fc9cc83fb6243eb63d0923ff2d880feafd03a04d347aa5a564cfd78ebb9c799",
+  "variant": "v2",
+  "v1_repo": "gowitheflowlab/physics-bench-fluid-w-hardnegs",
+  "v2_text_version": "fluid_eval_queries_v2_dynamics_aligned_raw_parsed",
+  "v2_text_style": "eval-aligned raw structured query",
+  "v2_text_generator": "eval-aligned raw structured query generator",
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "0ff52088ba29da608c4fc1e5a6df0cb7ef2c054b59c3df51bc00954f8fe69b96"
+}

metadata.parquet

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

quality/validation.json

@@ -0,0 +1,22 @@
+{
+  "repo_id": "gowitheflowlab/physics-bench-fluid-train",
+  "rows": 700,
+  "columns": [
+    "text",
+    "video",
+    "hard_negative_texts",
+    "hard_negative_videos"
+  ],
+  "unique_positive_texts": 700,
+  "negatives_per_row": [
+    5
+  ],
+  "negative_text_matches_own_case_text": true,
+  "self_referencing_negatives": 0,
+  "staged_video_files": 700,
+  "all_referenced_videos_present": true,
+  "video_bytes": 264648455,
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "0ff52088ba29da608c4fc1e5a6df0cb7ef2c054b59c3df51bc00954f8fe69b96",
+  "text_version": "fluid_eval_queries_v2_dynamics_aligned_raw_parsed"
+}

source_metadata/build_hardnegs_v2_metadata.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""Build a v2 of a *-w-hardnegs dataset that keeps the v1 positive/negative pairing
+byte-for-byte and only rewrites `text` / `hard_negative_texts` using the eval-aligned
+raw query generator of the corresponding domain.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+FLUID_ROOT = Path("/mnt/iusers01/fatpou01/compsci01/r90629yl/src/Physics_bench/physics_bench_fluid")
+SOLID_ROOT = Path("/mnt/iusers01/fatpou01/compsci01/r90629yl/src/Physics_bench/physics_bench_solid")
+OPTICS_ROOT = Path("/mnt/iusers01/fatpou01/compsci01/r90629yl/src/Physics_bench/physics_bench_optics")
+DYNAMICS_ROOT = Path("/mnt/iusers01/fatpou01/compsci01/r90629yl/src/Physics_bench/physics_bench_dynamics")
+
+
+def _load_module(path: Path, name: str):
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def make_text_fn(domain: str):
+    if domain == "optics":
+        sys.path.insert(0, str(OPTICS_ROOT / "src"))
+        from physics_bench_optics import dataset as ds
+
+        def fn(case):
+            return ds._parsed_query_text(case, ds._case_tokens(case))
+
+        return fn, ds.QUERY_VERSION
+    if domain == "fluid":
+        exp = _load_module(FLUID_ROOT / "scripts" / "export_hf_fluid_test_format.py", "fluid_export")
+        return exp._eval_parsed_query_text, exp.EVAL_QUERY_VERSION
+    if domain == "solid":
+        sys.path.insert(0, str(SOLID_ROOT / "src"))
+        from physics_bench_solid import release_pipeline as rp
+
+        return rp._eval_parsed_query_text, rp.EVAL_QUERY_VERSION
+    if domain == "dynamics":
+        sys.path.insert(0, str(DYNAMICS_ROOT / "src"))
+        from physics_bench_dynamics import parsed_query as pqm
+
+        return pqm.generate_template_text, pqm.PARSED_QUERY_VERSION
+    raise ValueError(domain)
+
+
+def disambiguate(domain: str, texts: dict, cases: dict) -> dict:
+    if domain == "dynamics":
+        sys.path.insert(0, str(DYNAMICS_ROOT / "src"))
+        from physics_bench_dynamics import parsed_query as pqm
+
+        return pqm.disambiguate_texts(texts, cases)
+    if domain == "optics":
+        sys.path.insert(0, str(OPTICS_ROOT / "src"))
+        from physics_bench_optics import dataset as ds
+
+        case_vals = {cid: ds._case_tokens(cases[cid]) for cid in texts}
+        return ds.disambiguate_parsed_texts(texts, case_vals)
+    return texts
+
+
+def case_id_from_path(path: str) -> str:
+    return path.split("/")[-1].rsplit(".", 1)[0]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--domain", required=True, choices=["optics", "fluid", "solid", "dynamics"])
+    ap.add_argument("--v1-metadata", required=True, help="metadata.parquet downloaded from the v1 repo")
+    ap.add_argument("--train-cases", required=True, help="train cases.jsonl / release_cases.jsonl")
+    ap.add_argument("--out-dir", required=True)
+    ap.add_argument("--benchmark-cases", default=None,
+                    help="optional benchmark cases file; asserts train params differ (solid safety check)")
+    args = ap.parse_args()
+
+    text_fn, version = make_text_fn(args.domain)
+
+    cases: dict[str, dict] = {}
+    with open(args.train_cases) as fh:
+        for line in fh:
+            c = json.loads(line)
+            cases[str(c["case_id"])] = c
+
+    if args.benchmark_cases:
+        bench: dict[str, dict] = {}
+        with open(args.benchmark_cases) as fh:
+            for line in fh:
+                c = json.loads(line)
+                bench[str(c["case_id"])] = c
+        shared = sorted(set(cases) & set(bench))
+        identical = [c for c in shared if cases[c].get("params") == bench[c].get("params")]
+        print(f"[safety] case_id shared with benchmark: {len(shared)}; identical params: {len(identical)}")
+        if identical:
+            raise ValueError(f"train metadata appears to be the benchmark set, e.g. {identical[:3]}")
+
+    table = pq.read_table(args.v1_metadata)
+    rows = table.to_pylist()
+
+    referenced: list[str] = []
+    for r in rows:
+        referenced.append(case_id_from_path(r["video"]))
+        referenced.extend(case_id_from_path(v) for v in r["hard_negative_videos"])
+    missing = sorted({c for c in referenced if c not in cases})
+    if missing:
+        raise ValueError(f"{len(missing)} referenced case_ids missing from train metadata, e.g. {missing[:3]}")
+
+    texts: dict[str, str] = {cid: text_fn(cases[cid]) for cid in sorted(set(referenced))}
+    texts = disambiguate(args.domain, texts, cases)
+
+    new_text = [texts[case_id_from_path(r["video"])] for r in rows]
+    new_negs = [[texts[case_id_from_path(v)] for v in r["hard_negative_videos"]] for r in rows]
+
+    dupes = {k: v for k, v in Counter(new_text).items() if v > 1}
+    if dupes:
+        raise ValueError(f"positive texts not unique: {len(dupes)} collisions")
+
+    names = table.schema.names
+    out_table = table.set_column(names.index("text"), table.schema.field(names.index("text")),
+                                pa.array(new_text, type=pa.string()))
+    out_table = out_table.set_column(names.index("hard_negative_texts"),
+                                     out_table.schema.field(names.index("hard_negative_texts")),
+                                     pa.array(new_negs, type=out_table.schema.field(names.index("hard_negative_texts")).type))
+
+    # pairing must be untouched
+    assert out_table.column("video").to_pylist() == table.column("video").to_pylist()
+    assert out_table.column("hard_negative_videos").to_pylist() == table.column("hard_negative_videos").to_pylist()
+
+    pair_repr = json.dumps(
+        [[r["video"], r["hard_negative_videos"]] for r in rows], separators=(",", ":"), sort_keys=False
+    )
+    pairing_sha = hashlib.sha256(pair_repr.encode()).hexdigest()
+
+    out = Path(args.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    pq.write_table(out_table, out / "metadata.parquet", compression="snappy", write_page_index=True)
+
+    summary = {
+        "domain": args.domain,
+        "text_version": version,
+        "text_style": "eval-aligned raw structured query",
+        "rows": len(rows),
+        "distinct_cases": len(texts),
+        "negatives_per_case": len(rows[0]["hard_negative_videos"]),
+        "pairing_identical_to_v1": True,
+        "pairing_sha256": pairing_sha,
+        "unique_positive_texts": len(set(new_text)),
+        "v1_metadata": args.v1_metadata,
+        "train_cases": args.train_cases,
+    }
+    (out / "v2_manifest.json").write_text(json.dumps(summary, indent=2))
+    sample = {"positive": new_text[0], "negatives": new_negs[0][:2],
+              "video": rows[0]["video"], "negative_videos": rows[0]["hard_negative_videos"][:2]}
+    (out / "sample.json").write_text(json.dumps(sample, indent=2))
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()

source_metadata/build_hf_hardneg_dataset.py

@@ -0,0 +1,484 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import shutil
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+NEGATIVE_COUNT = 5
+SOURCE_COLUMNS = ("query_id", "case_id", "raw_text", "parsed_text", "video")
+OUTPUT_COLUMNS = ("text", "video", "hard_negative_texts", "hard_negative_videos")
+
+HF_FEATURES = {
+    "text": {"dtype": "string", "_type": "Value"},
+    "video": {"dtype": "string", "_type": "Value"},
+    "hard_negative_texts": {
+        "feature": {"dtype": "string", "_type": "Value"},
+        "length": -1,
+        "_type": "List",
+    },
+    "hard_negative_videos": {
+        "feature": {"dtype": "string", "_type": "Value"},
+        "length": -1,
+        "_type": "List",
+    },
+}
+
+OUTPUT_SCHEMA = pa.schema(
+    [
+        pa.field("text", pa.string()),
+        pa.field("video", pa.string()),
+        pa.field("hard_negative_texts", pa.list_(pa.string())),
+        pa.field("hard_negative_videos", pa.list_(pa.string())),
+    ],
+    metadata={b"huggingface": json.dumps({"info": {"features": HF_FEATURES}}, separators=(",", ":")).encode()},
+)
+
+
+def _write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def _read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open(encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return rows
+
+
+def _source_files(source_dir: Path) -> list[tuple[str, Path]]:
+    return sorted(
+        ((path.parent.name, path) for path in source_dir.glob("*/train-*.parquet")),
+        key=lambda item: item[0],
+    )
+
+
+def _full_query_row(row: dict[str, Any]) -> bool:
+    query_id = str(row.get("query_id", ""))
+    return "__full__" in query_id or query_id.endswith("__full__00")
+
+
+def _read_source_full_rows(source_dir: Path, case_to_family: dict[str, str]) -> dict[str, list[dict[str, Any]]]:
+    family_rows: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    seen_cases: set[str] = set()
+    for _scenario, path in _source_files(source_dir):
+        table = pq.read_table(path)
+        if tuple(table.column_names) != SOURCE_COLUMNS:
+            raise ValueError(f"Unexpected source columns in {path}: {table.column_names}")
+        for row in table.to_pylist():
+            if not _full_query_row(row):
+                continue
+            case_id = str(row["case_id"])
+            if case_id in seen_cases:
+                raise ValueError(f"Duplicate full-query row for case {case_id}")
+            family = case_to_family.get(case_id)
+            if family is None:
+                raise KeyError(f"No high-level family mapping for case {case_id}")
+            row = dict(row)
+            row["family"] = family
+            family_rows[family].append(row)
+            seen_cases.add(case_id)
+    return {family: sorted(rows, key=lambda row: str(row["case_id"])) for family, rows in sorted(family_rows.items())}
+
+
+def _case_family_map(cases_jsonl: Path) -> dict[str, str]:
+    rows = _read_jsonl(cases_jsonl)
+    out: dict[str, str] = {}
+    for row in rows:
+        case_id = str(row["case_id"])
+        family = str(row["family"])
+        if case_id in out:
+            raise ValueError(f"Duplicate case_id in cases.jsonl: {case_id}")
+        out[case_id] = family
+    return out
+
+
+def _sample_assignments(family_rows: dict[str, list[dict[str, Any]]], *, seed: int) -> dict[str, dict[str, list[str]]]:
+    rng = random.Random(seed)
+    assignments: dict[str, dict[str, list[str]]] = {}
+    for family in sorted(family_rows):
+        rows = sorted(family_rows[family], key=lambda row: str(row["case_id"]))
+        family_assignments: dict[str, list[str]] = {}
+        for row in rows:
+            case_id = str(row["case_id"])
+            candidates = sorted(str(candidate["case_id"]) for candidate in rows if str(candidate["case_id"]) != case_id)
+            family_assignments[case_id] = rng.sample(candidates, NEGATIVE_COUNT)
+        assignments[family] = family_assignments
+    return assignments
+
+
+def _assignment_digest(assignments: dict[str, dict[str, list[str]]]) -> str:
+    payload = [
+        {"family": family, "case_id": case_id, "negative_case_ids": assignments[family][case_id]}
+        for family in sorted(assignments)
+        for case_id in sorted(assignments[family])
+    ]
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def _video_relpath(family: str, case_id: str) -> str:
+    return f"videos/{family}/{case_id}.mp4"
+
+
+def _video_bytes(row: dict[str, Any]) -> bytes:
+    video_value = row.get("video")
+    if not isinstance(video_value, dict) or video_value.get("bytes") is None:
+        raise ValueError(f"Source row for {row.get('case_id')} does not contain embedded video bytes")
+    return bytes(video_value["bytes"])
+
+
+def _update_video_digest(digest: Any, relpath: str, data: bytes) -> None:
+    digest.update(relpath.encode())
+    digest.update(b"\0")
+    digest.update(data)
+    digest.update(b"\n")
+
+
+def _feature_yaml(indent: str = "  ") -> list[str]:
+    return [
+        f"{indent}- name: text",
+        f"{indent}  dtype: string",
+        f"{indent}- name: video",
+        f"{indent}  dtype: string",
+        f"{indent}- name: hard_negative_texts",
+        f"{indent}  list: string",
+        f"{indent}- name: hard_negative_videos",
+        f"{indent}  list: string",
+    ]
+
+
+def _readme(
+    *,
+    repo_id: str,
+    source_repo: str,
+    seed: int,
+    total_rows: int,
+    metadata_size: int,
+    video_size: int,
+    family_count: int,
+) -> str:
+    total_size = metadata_size + video_size
+    lines = [
+        "---",
+        "dataset_info:",
+        "  features:",
+        *_feature_yaml("  "),
+        "  splits:",
+        "  - name: train",
+        f"    num_bytes: {total_size}",
+        f"    num_examples: {total_rows}",
+        f"  download_size: {total_size}",
+        f"  dataset_size: {total_size}",
+        "configs:",
+        "- config_name: default",
+        "  data_files:",
+        "  - split: train",
+        "    path: metadata.parquet",
+        "---",
+        "",
+        "# Physics Bench Fluid With Hard Negatives",
+        "",
+        f"Repository: `{repo_id}`",
+        "",
+        f"Source dataset: `{source_repo}`",
+        "",
+        "This repository uses a path-based VideoFolder-style layout for direct positive and hard-negative loading.",
+        "",
+        f"- rows: {total_rows}",
+        "- metadata columns: `text`, `video`, `hard_negative_texts`, `hard_negative_videos`",
+        "- positive text: query 1 (`__full__00`) from the source row",
+        f"- hard negatives per row: {NEGATIVE_COUNT}",
+        "- video paths: repository-relative `videos/<family>/<case_id>.mp4`",
+        "- list alignment: `hard_negative_texts[i]` and `hard_negative_videos[i]` come from the same case",
+        "- candidate pool: only the other 99 cases in the positive case's high-level fluid family",
+        "",
+        "## Reproducibility",
+        "",
+        f"- global seed: {seed}",
+        "- traversal: family alphabetical order, then case_id order",
+        f"- sampling: one `random.Random(seed)` stream for all {total_rows} rows",
+        "- selection: `random.sample(sorted(other_99_case_ids), 5)`",
+        f"- high-level fluid families: {family_count}",
+        "",
+        "## Loading",
+        "",
+        "```python",
+        "from pathlib import Path",
+        "import pyarrow.parquet as pq",
+        "from huggingface_hub import snapshot_download",
+        "",
+        f"root = Path(snapshot_download(\"{repo_id}\", repo_type=\"dataset\"))",
+        "rows = pq.read_table(root / \"metadata.parquet\").to_pylist()",
+        "row = rows[0]",
+        "positive_video = root / row[\"video\"]",
+        "negative_videos = [root / path for path in row[\"hard_negative_videos\"]]",
+        "```",
+        "",
+        "The training metadata intentionally contains only the four requested columns. Case IDs, query IDs, and sampled assignments are retained in `source_metadata/sampling_manifest.json` for auditing.",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def _validate_output(
+    *,
+    out_dir: Path,
+    metadata_rows: list[dict[str, Any]],
+    family_rows: dict[str, list[dict[str, Any]]],
+    expected_total_rows: int,
+    source_video_hash: str,
+) -> dict[str, Any]:
+    errors: list[str] = []
+    table = pq.read_table(out_dir / "metadata.parquet")
+    if tuple(table.column_names) != OUTPUT_COLUMNS:
+        errors.append(f"metadata columns are {table.column_names}, expected {OUTPUT_COLUMNS}")
+    written_rows = table.to_pylist()
+    if len(written_rows) != expected_total_rows:
+        errors.append(f"metadata has {len(written_rows)} rows, expected {expected_total_rows}")
+    if written_rows != metadata_rows:
+        errors.append("metadata changed during parquet serialization")
+
+    source_by_path: dict[str, dict[str, Any]] = {}
+    source_by_case: dict[str, tuple[str, dict[str, Any]]] = {}
+    for family, rows in family_rows.items():
+        for row in rows:
+            case_id = str(row["case_id"])
+            source_by_path[_video_relpath(family, case_id)] = row
+            source_by_case[case_id] = (family, row)
+
+    output_digest = hashlib.sha256()
+    seen_positive_paths: set[str] = set()
+    hard_negative_pairs = 0
+    cross_family_count = 0
+    self_negative_count = 0
+    for row in written_rows:
+        video = str(row["video"])
+        source = source_by_path.get(video)
+        if source is None:
+            errors.append(f"positive video path is unknown: {video}")
+            continue
+        family = Path(video).parts[1]
+        if video in seen_positive_paths:
+            errors.append(f"duplicate positive video path: {video}")
+        seen_positive_paths.add(video)
+        if str(row["text"]) != str(source["raw_text"]):
+            errors.append(f"positive text mismatch: {video}")
+        neg_texts = list(row["hard_negative_texts"])
+        neg_videos = [str(path) for path in row["hard_negative_videos"]]
+        if len(neg_texts) != NEGATIVE_COUNT or len(neg_videos) != NEGATIVE_COUNT:
+            errors.append(f"{video}: expected five hard negatives")
+        if len(set(neg_videos)) != NEGATIVE_COUNT:
+            errors.append(f"{video}: hard-negative videos are not unique")
+        for neg_text, neg_video in zip(neg_texts, neg_videos):
+            hard_negative_pairs += 1
+            neg_source = source_by_path.get(neg_video)
+            if neg_source is None:
+                errors.append(f"{video}: unknown hard-negative path {neg_video}")
+                continue
+            if Path(neg_video).parts[1] != family:
+                cross_family_count += 1
+            if neg_video == video:
+                self_negative_count += 1
+            if str(neg_text) != str(neg_source["raw_text"]):
+                errors.append(f"{video}: hard-negative text/path mismatch for {neg_video}")
+
+    if cross_family_count:
+        errors.append(f"found {cross_family_count} cross-family hard negatives")
+    if self_negative_count:
+        errors.append(f"found {self_negative_count} self hard negatives")
+
+    missing_videos: list[str] = []
+    for relpath in sorted(source_by_path):
+        path = out_dir / relpath
+        if not path.is_file() or path.stat().st_size == 0:
+            missing_videos.append(relpath)
+            continue
+        _update_video_digest(output_digest, relpath, path.read_bytes())
+    output_video_hash = output_digest.hexdigest()
+    if output_video_hash != source_video_hash:
+        errors.append("video bytes changed while creating the VideoFolder")
+
+    return {
+        "passed": not errors,
+        "errors": errors[:100],
+        "metadata_rows": len(written_rows),
+        "metadata_columns": table.column_names,
+        "video_files": len(source_by_path) - len(missing_videos),
+        "missing_videos": missing_videos[:100],
+        "hard_negative_pairs": hard_negative_pairs,
+        "cross_family_hard_negatives": cross_family_count,
+        "self_hard_negatives": self_negative_count,
+        "source_video_sha256": source_video_hash,
+        "output_video_sha256": output_video_hash,
+        "video_bytes_preserved": source_video_hash == output_video_hash,
+    }
+
+
+def build_dataset(
+    *,
+    source_dir: Path,
+    cases_jsonl: Path,
+    out_dir: Path,
+    repo_id: str,
+    source_repo: str,
+    seed: int,
+    expected_rows_per_family: int,
+    expected_total_rows: int,
+) -> dict[str, Any]:
+    if out_dir.exists() and any(out_dir.iterdir()):
+        raise FileExistsError(f"Output directory is not empty: {out_dir}")
+    case_to_family = _case_family_map(cases_jsonl)
+    family_rows = _read_source_full_rows(source_dir, case_to_family)
+    bad_counts = {family: len(rows) for family, rows in family_rows.items() if len(rows) != expected_rows_per_family}
+    if bad_counts:
+        raise ValueError(f"Expected {expected_rows_per_family} rows per high-level family: {bad_counts}")
+    if sum(map(len, family_rows.values())) != expected_total_rows:
+        raise ValueError(f"Expected {expected_total_rows} rows in total")
+
+    assignments = _sample_assignments(family_rows, seed=seed)
+    repeated = _sample_assignments(family_rows, seed=seed)
+    if assignments != repeated:
+        raise AssertionError("Hard-negative sampling is not reproducible")
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    metadata_rows: list[dict[str, Any]] = []
+    manifest_rows: list[dict[str, Any]] = []
+    source_video_digest = hashlib.sha256()
+    video_size = 0
+
+    for family in sorted(family_rows):
+        rows = family_rows[family]
+        by_case = {str(row["case_id"]): row for row in rows}
+        for source_row in rows:
+            case_id = str(source_row["case_id"])
+            query_id = str(source_row["query_id"])
+            relpath = _video_relpath(family, case_id)
+            video_bytes = _video_bytes(source_row)
+            video_path = out_dir / relpath
+            video_path.parent.mkdir(parents=True, exist_ok=True)
+            video_path.write_bytes(video_bytes)
+            video_size += len(video_bytes)
+            _update_video_digest(source_video_digest, relpath, video_bytes)
+
+            negative_case_ids = assignments[family][case_id]
+            negative_rows = [by_case[negative_id] for negative_id in negative_case_ids]
+            negative_paths = [_video_relpath(family, negative_id) for negative_id in negative_case_ids]
+            metadata_rows.append(
+                {
+                    "text": str(source_row["raw_text"]),
+                    "video": relpath,
+                    "hard_negative_texts": [str(row["raw_text"]) for row in negative_rows],
+                    "hard_negative_videos": negative_paths,
+                }
+            )
+            manifest_rows.append(
+                {
+                    "family": family,
+                    "case_id": case_id,
+                    "query_id": query_id,
+                    "video": relpath,
+                    "negative_case_ids": negative_case_ids,
+                    "negative_query_ids": [str(row["query_id"]) for row in negative_rows],
+                    "hard_negative_videos": negative_paths,
+                }
+            )
+
+    metadata_path = out_dir / "metadata.parquet"
+    table = pa.Table.from_pylist(metadata_rows, schema=OUTPUT_SCHEMA)
+    pq.write_table(table, metadata_path, compression="snappy", row_group_size=100, write_page_index=True)
+    source_video_hash = source_video_digest.hexdigest()
+    validation = _validate_output(
+        out_dir=out_dir,
+        metadata_rows=metadata_rows,
+        family_rows=family_rows,
+        expected_total_rows=expected_total_rows,
+        source_video_hash=source_video_hash,
+    )
+    validation.update(
+        {
+            "repo_id": repo_id,
+            "source_repo": source_repo,
+            "seed": seed,
+            "family_count": len(family_rows),
+            "rows_per_family": {family: len(rows) for family, rows in family_rows.items()},
+            "assignment_sha256": _assignment_digest(assignments),
+            "second_pass_assignment_sha256": _assignment_digest(repeated),
+            "reproducibility_verified": assignments == repeated,
+            "single_rng_stream": True,
+            "traversal_order": "family alphabetical, then case_id",
+        }
+    )
+    _write_json(out_dir / "quality" / "validation.json", validation)
+    _write_json(
+        out_dir / "generation_manifest.json",
+        {
+            "repo_id": repo_id,
+            "source_repo": source_repo,
+            "seed": seed,
+            "algorithm": "one random.Random(seed) stream; sorted high-level families; sorted case_id; random.sample(sorted(other_99_case_ids), 5)",
+            "family_count": len(family_rows),
+            "total_rows": len(metadata_rows),
+            "assignment_sha256": _assignment_digest(assignments),
+        },
+    )
+    _write_json(out_dir / "source_metadata" / "sampling_manifest.json", manifest_rows)
+    _write_json(out_dir / "source_metadata" / "family_case_counts.json", {family: len(rows) for family, rows in family_rows.items()})
+    shutil.copy2(cases_jsonl, out_dir / "source_metadata" / "cases.jsonl")
+    shutil.copy2(Path(__file__).resolve(), out_dir / "source_metadata" / "build_hf_hardneg_dataset.py")
+    (out_dir / ".gitattributes").write_text("*.mp4 filter=lfs diff=lfs merge=lfs -text\n", encoding="utf-8")
+    (out_dir / "README.md").write_text(
+        _readme(
+            repo_id=repo_id,
+            source_repo=source_repo,
+            seed=seed,
+            total_rows=len(metadata_rows),
+            metadata_size=metadata_path.stat().st_size,
+            video_size=video_size,
+            family_count=len(family_rows),
+        ),
+        encoding="utf-8",
+    )
+    if not validation["passed"]:
+        raise ValueError(f"Validation failed: {validation['errors'][:10]}")
+    return validation
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Build path-based fluid hard-negative VideoFolder data.")
+    parser.add_argument("--source-dir", type=Path, required=True, help="Previewable HF source layout with scenario/train-*.parquet files.")
+    parser.add_argument("--cases-jsonl", type=Path, required=True, help="cases.jsonl containing high-level family for each case.")
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument("--repo-id", default="gowitheflowlab/physics-bench-fluid-w-hardnegs")
+    parser.add_argument("--source-repo", default="gowitheflowlab/physics-bench-fluid-train-700")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--expected-rows-per-family", type=int, default=100)
+    parser.add_argument("--expected-total-rows", type=int, default=700)
+    args = parser.parse_args()
+    result = build_dataset(
+        source_dir=args.source_dir.resolve(),
+        cases_jsonl=args.cases_jsonl.resolve(),
+        out_dir=args.out_dir.resolve(),
+        repo_id=args.repo_id,
+        source_repo=args.source_repo,
+        seed=args.seed,
+        expected_rows_per_family=args.expected_rows_per_family,
+        expected_total_rows=args.expected_total_rows,
+    )
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

source_metadata/family_case_counts.json

@@ -0,0 +1,9 @@
+{
+  "buoyancy": 100,
+  "cavity": 100,
+  "external_aero": 100,
+  "external_wake": 100,
+  "internal_step": 100,
+  "jet_axi": 100,
+  "scalar_transport": 100
+}

source_metadata/v2_manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "fluid",
+  "text_version": "fluid_eval_queries_v2_dynamics_aligned_raw_parsed",
+  "text_style": "eval-aligned raw structured query",
+  "rows": 700,
+  "distinct_cases": 700,
+  "negatives_per_case": 5,
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "0ff52088ba29da608c4fc1e5a6df0cb7ef2c054b59c3df51bc00954f8fe69b96",
+  "unique_positive_texts": 700,
+  "v1_metadata": "/net/scratch/r90629yl/Physics_bench/hardnegs_v2/fluid_v1/metadata.parquet",
+  "train_cases": "/net/scratch/r90629yl/Physics_bench/physics_bench_fluid/workspace/train_family700_curated_20260716_s20260716/dataset/cases.jsonl"
+}

videos/jet_axi/jetaxi_Re1100_s026_train20260716.mp4

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

videos/jet_axi/jetaxi_Re11950_s059_train20260716.mp4

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

videos/jet_axi/jetaxi_Re1250_s027_train20260716.mp4

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

videos/jet_axi/jetaxi_Re13350_s061_train20260716.mp4

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

videos/jet_axi/jetaxi_Re1550_s031_train20260716.mp4

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

videos/jet_axi/jetaxi_Re15600_s063_train20260716.mp4

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

videos/jet_axi/jetaxi_Re160_s001_train20260716.mp4

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

videos/jet_axi/jetaxi_Re175_s003_train20260716.mp4

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

videos/jet_axi/jetaxi_Re18600_s066_train20260716.mp4

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

videos/jet_axi/jetaxi_Re1975_s016_train20260716.mp4

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

videos/jet_axi/jetaxi_Re2125_s024_train20260716.mp4

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

videos/jet_axi/jetaxi_Re2150_s012_train20260716.mp4

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

videos/jet_axi/jetaxi_Re2150_s060_train20260716.mp4

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

videos/jet_axi/jetaxi_Re2325_s040_train20260716.mp4

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

videos/jet_axi/jetaxi_Re2350_s000_train20260716.mp4

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

videos/jet_axi/jetaxi_Re2500_s048_train20260716.mp4

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

videos/jet_axi/jetaxi_Re3250_s039_train20260716.mp4

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

videos/jet_axi/jetaxi_Re340_s011_train20260716.mp4

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

videos/jet_axi/jetaxi_Re390_s013_train20260716.mp4

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

videos/jet_axi/jetaxi_Re4975_s045_train20260716.mp4

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

videos/jet_axi/jetaxi_Re5200_s046_train20260716.mp4

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

videos/jet_axi/jetaxi_Re5250_s047_train20260716.mp4

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

videos/jet_axi/jetaxi_Re550_s017_train20260716.mp4

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

videos/jet_axi/jetaxi_Re790_s021_train20260716.mp4

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

videos/jet_axi/jetaxi_Re8000_s053_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re12600_s017_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re14450_s032_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re16100_s024_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re16300_s023_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re16600_s036_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re19700_s027_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re21500_s008_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re24000_s035_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re25600_s038_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re28100_s056_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re35400_s055_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re38400_s059_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re5650_s002_train20260716.mp4

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

videos/jet_axi/jetaxi_turb_Re9500_s010_train20260716.mp4

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