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: 1196774502
+    num_examples: 1900
+  download_size: 1196774502
+  dataset_size: 1196774502
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: metadata.parquet
+---
+
+# Physics Bench Dynamics Train
+
+Repository: `gowitheflowlab/physics-bench-dynamics-train`
+
+Training split with hard negatives for dynamics simulation video retrieval.
+
+- rows: 1900
+- 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 (`dynamics_parsed_v1_recovered_5sentence`),
+  matching the `parsed_text` column of `gowitheflowlab/physics-bench-dynamics-eval-1900`
+- 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: `01e5e7ec5576209c`
+- 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-dynamics-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-dynamics-train",
+  "source_repo": "gowitheflowlab/physics-bench-dynamics-train-1900",
+  "seed": 42,
+  "algorithm": "one random.Random(seed) stream; sorted families; sorted case_id; random.sample(other_99, 5)",
+  "family_count": 19,
+  "total_rows": 1900,
+  "assignment_sha256": "ac7b768558384581b1fcaf5208a3334f632cc857fe0aa5f6eb128b7a44cc8a2d",
+  "variant": "v2",
+  "v1_repo": "gowitheflowlab/physics-bench-dynamics-w-hardnegs",
+  "v2_text_version": "dynamics_parsed_v1_recovered_5sentence",
+  "v2_text_style": "eval-aligned raw structured query",
+  "v2_text_generator": "eval-aligned raw structured query generator",
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "01e5e7ec5576209c3a1a12cac856abd8ecc2683706fd02d43fe60f1c2280ad85"
+}

metadata.parquet

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

quality/validation.json

@@ -0,0 +1,22 @@
+{
+  "repo_id": "gowitheflowlab/physics-bench-dynamics-train",
+  "rows": 1900,
+  "columns": [
+    "text",
+    "video",
+    "hard_negative_texts",
+    "hard_negative_videos"
+  ],
+  "unique_positive_texts": 1900,
+  "negatives_per_row": [
+    5
+  ],
+  "negative_text_matches_own_case_text": true,
+  "self_referencing_negatives": 0,
+  "staged_video_files": 1900,
+  "all_referenced_videos_present": true,
+  "video_bytes": 1196359570,
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "01e5e7ec5576209c3a1a12cac856abd8ecc2683706fd02d43fe60f1c2280ad85",
+  "text_version": "dynamics_parsed_v1_recovered_5sentence"
+}

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,501 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+import shutil
+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 _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 _read_family(path: Path) -> list[dict[str, Any]]:
+    table = pq.read_table(path)
+    if tuple(table.column_names) != SOURCE_COLUMNS:
+        raise ValueError(f"Unexpected source columns in {path}: {table.column_names}")
+    return sorted(table.to_pylist(), key=lambda row: str(row["case_id"]))
+
+
+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 = [
+                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 _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,
+) -> 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 Dynamics 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__0`) 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 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)`",
+        "",
+        "## 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 and query IDs 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]] = {}
+    for family, rows in family_rows.items():
+        for row in rows:
+            source_by_path[_video_relpath(family, str(row["case_id"]))] = 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 = []
+    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,
+    out_dir: Path,
+    repo_id: str,
+    source_repo: str,
+    seed: int,
+    expected_rows_per_family: int,
+    expected_total_rows: int,
+) -> dict[str, Any]:
+    source_files = _source_files(source_dir)
+    if not source_files:
+        raise FileNotFoundError(
+            f"No source family parquet files found under {source_dir}"
+        )
+    family_rows = {
+        family: _read_family(path) for family, path in source_files
+    }
+    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 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")
+
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    out_dir.mkdir(parents=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"])
+            if query_id != f"{case_id}__full__0":
+                raise ValueError(
+                    f"Source row is not the expected dynamics query 1: {query_id}"
+                )
+            relpath = _video_relpath(family, case_id)
+            video_value = source_row["video"]
+            video_bytes = bytes(video_value["bytes"])
+            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 families; sorted "
+                "case_id; random.sample(other_99, 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
+    )
+    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,
+        ),
+        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 dynamics hard-negative VideoFolder data."
+    )
+    parser.add_argument("--source-dir", type=Path, required=True)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument(
+        "--repo-id",
+        default="gowitheflowlab/physics-bench-dynamics-w-hardnegs",
+    )
+    parser.add_argument(
+        "--source-repo",
+        default="gowitheflowlab/physics-bench-dynamics-train-1900",
+    )
+    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=1900)
+    args = parser.parse_args()
+    result = build_dataset(
+        source_dir=args.source_dir.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/v2_manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "dynamics",
+  "text_version": "dynamics_parsed_v1_recovered_5sentence",
+  "text_style": "eval-aligned raw structured query",
+  "rows": 1900,
+  "distinct_cases": 1900,
+  "negatives_per_case": 5,
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "01e5e7ec5576209c3a1a12cac856abd8ecc2683706fd02d43fe60f1c2280ad85",
+  "unique_positive_texts": 1900,
+  "v1_metadata": "/net/scratch/r90629yl/Physics_bench/hardnegs_v2/dynamics_v1/metadata.parquet",
+  "train_cases": "/mnt/iusers01/fatpou01/compsci01/r90629yl/src/Physics_bench/physics_bench_dynamics/workspace/train_1900_20260715/dataset/cases.jsonl"
+}

videos/reissnerShellModal/reissnerShellModal_S301.mp4

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

videos/reissnerShellModal/reissnerShellModal_S302.mp4

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

videos/reissnerShellModal/reissnerShellModal_S304.mp4

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

videos/reissnerShellModal/reissnerShellModal_S309.mp4

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

videos/reissnerShellModal/reissnerShellModal_S311.mp4

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

videos/reissnerShellModal/reissnerShellModal_S315.mp4

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

videos/reissnerShellModal/reissnerShellModal_S316.mp4

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

videos/reissnerShellModal/reissnerShellModal_S317.mp4

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

videos/reissnerShellModal/reissnerShellModal_S318.mp4

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

videos/reissnerShellModal/reissnerShellModal_S321.mp4

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

videos/reissnerShellModal/reissnerShellModal_S322.mp4

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

videos/reissnerShellModal/reissnerShellModal_S323.mp4

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

videos/reissnerShellModal/reissnerShellModal_S324.mp4

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

videos/reissnerShellModal/reissnerShellModal_S325.mp4

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

videos/reissnerShellModal/reissnerShellModal_S328.mp4

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

videos/reissnerShellModal/reissnerShellModal_S331.mp4

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

videos/reissnerShellModal/reissnerShellModal_S333.mp4

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

videos/reissnerShellModal/reissnerShellModal_S336.mp4

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

videos/reissnerShellModal/reissnerShellModal_S338.mp4

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

videos/reissnerShellModal/reissnerShellModal_S340.mp4

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

videos/reissnerShellModal/reissnerShellModal_S341.mp4

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

videos/reissnerShellModal/reissnerShellModal_S343.mp4

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

videos/reissnerShellModal/reissnerShellModal_S344.mp4

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

videos/reissnerShellModal/reissnerShellModal_S346.mp4

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

videos/reissnerShellModal/reissnerShellModal_S350.mp4

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

videos/reissnerShellModal/reissnerShellModal_S352.mp4

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

videos/reissnerShellModal/reissnerShellModal_S353.mp4

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

videos/reissnerShellModal/reissnerShellModal_S358.mp4

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

videos/reissnerShellModal/reissnerShellModal_S360.mp4

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

videos/reissnerShellModal/reissnerShellModal_S364.mp4

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

videos/reissnerShellModal/reissnerShellModal_S369.mp4

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

videos/reissnerShellModal/reissnerShellModal_S373.mp4

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

videos/reissnerShellModal/reissnerShellModal_S374.mp4

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

videos/reissnerShellModal/reissnerShellModal_S378.mp4

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

videos/reissnerShellModal/reissnerShellModal_S380.mp4

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

videos/reissnerShellModal/reissnerShellModal_S386.mp4

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

videos/reissnerShellModal/reissnerShellModal_S388.mp4

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

videos/reissnerShellModal/reissnerShellModal_S391.mp4

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

videos/reissnerShellModal/reissnerShellModal_S392.mp4

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

videos/reissnerShellModal/reissnerShellModal_S395.mp4

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

videos/reissnerShellModal/reissnerShellModal_S396.mp4

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