#!/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//.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()