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: 956204969
+    num_examples: 2700
+  download_size: 956204969
+  dataset_size: 956204969
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: metadata.parquet
+---
+
+# Physics Bench Solid Train
+
+Repository: `gowitheflowlab/physics-bench-solid-train`
+
+Training split with hard negatives for solid simulation video retrieval.
+
+- rows: 2700
+- 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 (`solid_eval_queries_v4_dynamics_aligned_raw_parsed`),
+  matching the `parsed_text` column of `gowitheflowlab/physics-bench-solid-eval-2700`
+- 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: `a9c1db6e65fb206f`
+- 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-solid-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,17 @@
+{
+  "repo_id": "gowitheflowlab/physics-bench-solid-train",
+  "source_repo": "gowitheflowlab/physics-bench-solid-train-2700",
+  "seed": 42,
+  "query_suffix": "__query_1",
+  "algorithm": "one random.Random(seed) stream; sorted families; sorted case_id; random.sample(other_99, 5)",
+  "family_count": 27,
+  "total_rows": 2700,
+  "assignment_sha256": "666ca8db70d4b46e9998ae2a99883d5e5796e51a3067845d6adfdef6bf47ea95",
+  "variant": "v2",
+  "v1_repo": "gowitheflowlab/physics-bench-solid-w-hardnegs",
+  "v2_text_version": "solid_eval_queries_v4_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": "a9c1db6e65fb206f7aea42a1e2abf1f78c9337afd9cc21594ab3ce281aaf2e2d"
+}

metadata.parquet

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

quality/validation.json

@@ -0,0 +1,22 @@
+{
+  "repo_id": "gowitheflowlab/physics-bench-solid-train",
+  "rows": 2700,
+  "columns": [
+    "text",
+    "video",
+    "hard_negative_texts",
+    "hard_negative_videos"
+  ],
+  "unique_positive_texts": 2700,
+  "negatives_per_row": [
+    5
+  ],
+  "negative_text_matches_own_case_text": true,
+  "self_referencing_negatives": 0,
+  "staged_video_files": 2700,
+  "all_referenced_videos_present": true,
+  "video_bytes": 955579998,
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "a9c1db6e65fb206f7aea42a1e2abf1f78c9337afd9cc21594ab3ce281aaf2e2d",
+  "text_version": "solid_eval_queries_v4_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,549 @@
+#!/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.compute as pc
+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_query_rows(
+    path: Path,
+    *,
+    query_suffix: str,
+    include_video: bool,
+) -> list[dict[str, Any]]:
+    columns = list(SOURCE_COLUMNS if include_video else SOURCE_COLUMNS[:-1])
+    table = pq.read_table(path, columns=columns)
+    filtered = table.filter(pc.ends_with(table["query_id"], pattern=query_suffix))
+    return sorted(filtered.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])
+    ]
+    serialized = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(serialized.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 _readme(
+    *,
+    repo_id: str,
+    source_repo: str,
+    seed: int,
+    query_suffix: str,
+    total_rows: int,
+    metadata_size: int,
+    video_size: int,
+) -> str:
+    total_size = metadata_size + video_size
+    return "\n".join(
+        [
+            "---",
+            "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",
+            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 Solid With Hard Negatives",
+            "",
+            f"Repository: `{repo_id}`",
+            "",
+            f"Source dataset: `{source_repo}`",
+            "",
+            "This repository follows the path-based layout of "
+            "`gowitheflowlab/physics-bench-optics-w-hardnegs`.",
+            "",
+            f"- rows: {total_rows}",
+            "- metadata columns: `text`, `video`, `hard_negative_texts`, "
+            "`hard_negative_videos`",
+            f"- positive text: query 1 (`{query_suffix}`) from the source case",
+            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 retrieval "
+            "columns. Case IDs and query IDs are retained in "
+            "`source_metadata/sampling_manifest.json` for auditing.",
+            "",
+        ]
+    )
+
+
+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:
+            relpath = _video_relpath(family, str(row["case_id"]))
+            source_by_path[relpath] = row
+
+    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}")
+
+        negative_texts = list(row["hard_negative_texts"])
+        negative_videos = [str(path) for path in row["hard_negative_videos"]]
+        if (
+            len(negative_texts) != NEGATIVE_COUNT
+            or len(negative_videos) != NEGATIVE_COUNT
+        ):
+            errors.append(f"{video}: expected five hard negatives")
+        if len(set(negative_videos)) != NEGATIVE_COUNT:
+            errors.append(f"{video}: hard-negative videos are not unique")
+        for negative_text, negative_video in zip(
+            negative_texts,
+            negative_videos,
+        ):
+            hard_negative_pairs += 1
+            negative_source = source_by_path.get(negative_video)
+            if negative_source is None:
+                errors.append(f"{video}: unknown hard-negative path {negative_video}")
+                continue
+            if Path(negative_video).parts[1] != family:
+                cross_family_count += 1
+            if negative_video == video:
+                self_negative_count += 1
+            if str(negative_text) != str(negative_source["raw_text"]):
+                errors.append(
+                    f"{video}: hard-negative text/path mismatch for {negative_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")
+
+    output_digest = hashlib.sha256()
+    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 hard-negative dataset")
+
+    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,
+    query_suffix: str,
+    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_query_rows(
+            path,
+            query_suffix=query_suffix,
+            include_video=False,
+        )
+        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} query-1 rows per family: {bad_counts}"
+        )
+    if sum(map(len, family_rows.values())) != expected_total_rows:
+        raise ValueError(f"Expected {expected_total_rows} query-1 rows in total")
+    for family, rows in family_rows.items():
+        case_ids = [str(row["case_id"]) for row in rows]
+        if len(case_ids) != len(set(case_ids)):
+            raise ValueError(f"Duplicate query-1 case IDs in family {family}")
+
+    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
+    source_file_map = dict(source_files)
+    for family in sorted(family_rows):
+        rows = family_rows[family]
+        by_case = {str(row["case_id"]): row for row in rows}
+        rows_with_video = _read_query_rows(
+            source_file_map[family],
+            query_suffix=query_suffix,
+            include_video=True,
+        )
+        video_by_case = {
+            str(row["case_id"]): row["video"] for row in rows_with_video
+        }
+        if set(video_by_case) != set(by_case):
+            raise ValueError(f"Query/video case mismatch in family {family}")
+
+        for source_row in rows:
+            case_id = str(source_row["case_id"])
+            query_id = str(source_row["query_id"])
+            if not query_id.endswith(query_suffix):
+                raise ValueError(f"Unexpected query ID for query 1: {query_id}")
+
+            relpath = _video_relpath(family, case_id)
+            video_value = video_by_case[case_id]
+            video_bytes = bytes(video_value["bytes"])
+            if not video_bytes:
+                raise ValueError(f"Empty source video bytes for {case_id}")
+            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,
+                }
+            )
+
+        del rows_with_video
+        del video_by_case
+
+    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,
+    )
+    assignment_hash = _assignment_digest(assignments)
+    validation.update(
+        {
+            "repo_id": repo_id,
+            "source_repo": source_repo,
+            "seed": seed,
+            "query_suffix": query_suffix,
+            "family_count": len(family_rows),
+            "rows_per_family": {
+                family: len(rows) for family, rows in family_rows.items()
+            },
+            "assignment_sha256": assignment_hash,
+            "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,
+            "query_suffix": query_suffix,
+            "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_hash,
+        },
+    )
+    _write_json(
+        out_dir / "source_metadata" / "sampling_manifest.json",
+        manifest_rows,
+    )
+    shutil.copy2(
+        Path(__file__).resolve(),
+        out_dir / "source_metadata" / Path(__file__).name,
+    )
+    (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,
+            query_suffix=query_suffix,
+            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 a path-based solid hard-negative video dataset."
+    )
+    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-solid-w-hardnegs",
+    )
+    parser.add_argument(
+        "--source-repo",
+        default="gowitheflowlab/physics-bench-solid-train-2700",
+    )
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--query-suffix", default="__query_1")
+    parser.add_argument("--expected-rows-per-family", type=int, default=100)
+    parser.add_argument("--expected-total-rows", type=int, default=2700)
+    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,
+        query_suffix=args.query_suffix,
+        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": "solid",
+  "text_version": "solid_eval_queries_v4_dynamics_aligned_raw_parsed",
+  "text_style": "eval-aligned raw structured query",
+  "rows": 2700,
+  "distinct_cases": 2700,
+  "negatives_per_case": 5,
+  "pairing_identical_to_v1": true,
+  "pairing_sha256": "a9c1db6e65fb206f7aea42a1e2abf1f78c9337afd9cc21594ab3ce281aaf2e2d",
+  "unique_positive_texts": 2700,
+  "v1_metadata": "/net/scratch/r90629yl/Physics_bench/hardnegs_v2/solid_v1/metadata.parquet",
+  "train_cases": "/mnt/iusers01/fatpou01/compsci01/r90629yl/src/Physics_bench/physics_bench_solid/workspace/solid_train_2700_20260716/release_train/curated_cases.jsonl"
+}

videos/plateWithHole3D/plateWithHole3D_S003.mp4

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

videos/plateWithHole3D/plateWithHole3D_S004.mp4

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

videos/plateWithHole3D/plateWithHole3D_S010.mp4

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

videos/plateWithHole3D/plateWithHole3D_S020.mp4

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

videos/plateWithHole3D/plateWithHole3D_S025.mp4

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

videos/plateWithHole3D/plateWithHole3D_S033.mp4

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

videos/plateWithHole3D/plateWithHole3D_S058.mp4

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

videos/plateWithHole3D/plateWithHole3D_S059.mp4

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

videos/plateWithHole3D/plateWithHole3D_S067.mp4

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

videos/plateWithHole3D/plateWithHole3D_S069.mp4

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

videos/plateWithHole3D/plateWithHole3D_S070.mp4

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

videos/plateWithHole3D/plateWithHole3D_S081.mp4

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

videos/plateWithHole3D/plateWithHole3D_S092.mp4

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

videos/plateWithHole3D/plateWithHole3D_S094.mp4

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

videos/plateWithHole3D/plateWithHole3D_S099.mp4

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

videos/plateWithHole3D/plateWithHole3D_S115.mp4

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

videos/plateWithHole3D/plateWithHole3D_S128.mp4

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

videos/plateWithHole3D/plateWithHole3D_S135.mp4

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

videos/plateWithHole3D/plateWithHole3D_S171.mp4

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

videos/plateWithHole3D/plateWithHole3D_S183.mp4

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

videos/plateWithHole3D/plateWithHole3D_S188.mp4

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

videos/plateWithHole3D/plateWithHole3D_S191.mp4

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

videos/plateWithHole3D/plateWithHole3D_S197.mp4

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

videos/plateWithHole3D/plateWithHole3D_S199.mp4

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

videos/plateWithHole3D/plateWithHole3D_S201.mp4

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

videos/plateWithHole3D/plateWithHole3D_S202.mp4

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

videos/plateWithHole3D/plateWithHole3D_S227.mp4

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

videos/plateWithHole3D/plateWithHole3D_S228.mp4

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

videos/plateWithHole3D/plateWithHole3D_S233.mp4

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

videos/plateWithHole3D/plateWithHole3D_S234.mp4

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

videos/plateWithHole3D/plateWithHole3D_S241.mp4

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

videos/plateWithHole3D/plateWithHole3D_S251.mp4

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

videos/plateWithHole3D/plateWithHole3D_S257.mp4

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

videos/plateWithHole3D/plateWithHole3D_S271.mp4

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

videos/plateWithHole3D/plateWithHole3D_S272.mp4

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

videos/plateWithHole3D/plateWithHole3D_S274.mp4

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

videos/plateWithHole3D/plateWithHole3D_S279.mp4

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

videos/plateWithHole3D/plateWithHole3D_S284.mp4

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

videos/plateWithHole3D/plateWithHole3D_S289.mp4

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

videos/plateWithHole3D/plateWithHole3D_S298.mp4

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

videos/plateWithHole3D/plateWithHole3D_S303.mp4

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