source_metadata/build_hf_hardneg_dataset.py

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import hashlib
import json
import random
import shutil
from collections import defaultdict
from pathlib import Path
from typing import Any

import pyarrow as pa
import pyarrow.parquet as pq


NEGATIVE_COUNT = 5
SOURCE_COLUMNS = ("query_id", "case_id", "raw_text", "parsed_text", "video")
OUTPUT_COLUMNS = ("text", "video", "hard_negative_texts", "hard_negative_videos")

HF_FEATURES = {
    "text": {"dtype": "string", "_type": "Value"},
    "video": {"dtype": "string", "_type": "Value"},
    "hard_negative_texts": {
        "feature": {"dtype": "string", "_type": "Value"},
        "length": -1,
        "_type": "List",
    },
    "hard_negative_videos": {
        "feature": {"dtype": "string", "_type": "Value"},
        "length": -1,
        "_type": "List",
    },
}

OUTPUT_SCHEMA = pa.schema(
    [
        pa.field("text", pa.string()),
        pa.field("video", pa.string()),
        pa.field("hard_negative_texts", pa.list_(pa.string())),
        pa.field("hard_negative_videos", pa.list_(pa.string())),
    ],
    metadata={b"huggingface": json.dumps({"info": {"features": HF_FEATURES}}, separators=(",", ":")).encode()},
)


def _write_json(path: Path, payload: Any) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")


def _read_jsonl(path: Path) -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    with path.open(encoding="utf-8") as handle:
        for line in handle:
            line = line.strip()
            if line:
                rows.append(json.loads(line))
    return rows


def _source_files(source_dir: Path) -> list[tuple[str, Path]]:
    return sorted(
        ((path.parent.name, path) for path in source_dir.glob("*/train-*.parquet")),
        key=lambda item: item[0],
    )


def _full_query_row(row: dict[str, Any]) -> bool:
    query_id = str(row.get("query_id", ""))
    return "__full__" in query_id or query_id.endswith("__full__00")


def _read_source_full_rows(source_dir: Path, case_to_family: dict[str, str]) -> dict[str, list[dict[str, Any]]]:
    family_rows: dict[str, list[dict[str, Any]]] = defaultdict(list)
    seen_cases: set[str] = set()
    for _scenario, path in _source_files(source_dir):
        table = pq.read_table(path)
        if tuple(table.column_names) != SOURCE_COLUMNS:
            raise ValueError(f"Unexpected source columns in {path}: {table.column_names}")
        for row in table.to_pylist():
            if not _full_query_row(row):
                continue
            case_id = str(row["case_id"])
            if case_id in seen_cases:
                raise ValueError(f"Duplicate full-query row for case {case_id}")
            family = case_to_family.get(case_id)
            if family is None:
                raise KeyError(f"No high-level family mapping for case {case_id}")
            row = dict(row)
            row["family"] = family
            family_rows[family].append(row)
            seen_cases.add(case_id)
    return {family: sorted(rows, key=lambda row: str(row["case_id"])) for family, rows in sorted(family_rows.items())}


def _case_family_map(cases_jsonl: Path) -> dict[str, str]:
    rows = _read_jsonl(cases_jsonl)
    out: dict[str, str] = {}
    for row in rows:
        case_id = str(row["case_id"])
        family = str(row["family"])
        if case_id in out:
            raise ValueError(f"Duplicate case_id in cases.jsonl: {case_id}")
        out[case_id] = family
    return out


def _sample_assignments(family_rows: dict[str, list[dict[str, Any]]], *, seed: int) -> dict[str, dict[str, list[str]]]:
    rng = random.Random(seed)
    assignments: dict[str, dict[str, list[str]]] = {}
    for family in sorted(family_rows):
        rows = sorted(family_rows[family], key=lambda row: str(row["case_id"]))
        family_assignments: dict[str, list[str]] = {}
        for row in rows:
            case_id = str(row["case_id"])
            candidates = sorted(str(candidate["case_id"]) for candidate in rows if str(candidate["case_id"]) != case_id)
            family_assignments[case_id] = rng.sample(candidates, NEGATIVE_COUNT)
        assignments[family] = family_assignments
    return assignments


def _assignment_digest(assignments: dict[str, dict[str, list[str]]]) -> str:
    payload = [
        {"family": family, "case_id": case_id, "negative_case_ids": assignments[family][case_id]}
        for family in sorted(assignments)
        for case_id in sorted(assignments[family])
    ]
    return hashlib.sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).hexdigest()


def _video_relpath(family: str, case_id: str) -> str:
    return f"videos/{family}/{case_id}.mp4"


def _video_bytes(row: dict[str, Any]) -> bytes:
    video_value = row.get("video")
    if not isinstance(video_value, dict) or video_value.get("bytes") is None:
        raise ValueError(f"Source row for {row.get('case_id')} does not contain embedded video bytes")
    return bytes(video_value["bytes"])


def _update_video_digest(digest: Any, relpath: str, data: bytes) -> None:
    digest.update(relpath.encode())
    digest.update(b"\0")
    digest.update(data)
    digest.update(b"\n")


def _feature_yaml(indent: str = "  ") -> list[str]:
    return [
        f"{indent}- name: text",
        f"{indent}  dtype: string",
        f"{indent}- name: video",
        f"{indent}  dtype: string",
        f"{indent}- name: hard_negative_texts",
        f"{indent}  list: string",
        f"{indent}- name: hard_negative_videos",
        f"{indent}  list: string",
    ]


def _readme(
    *,
    repo_id: str,
    source_repo: str,
    seed: int,
    total_rows: int,
    metadata_size: int,
    video_size: int,
    family_count: int,
) -> str:
    total_size = metadata_size + video_size
    lines = [
        "---",
        "dataset_info:",
        "  features:",
        *_feature_yaml("  "),
        "  splits:",
        "  - name: train",
        f"    num_bytes: {total_size}",
        f"    num_examples: {total_rows}",
        f"  download_size: {total_size}",
        f"  dataset_size: {total_size}",
        "configs:",
        "- config_name: default",
        "  data_files:",
        "  - split: train",
        "    path: metadata.parquet",
        "---",
        "",
        "# Physics Bench Fluid With Hard Negatives",
        "",
        f"Repository: `{repo_id}`",
        "",
        f"Source dataset: `{source_repo}`",
        "",
        "This repository uses a path-based VideoFolder-style layout for direct positive and hard-negative loading.",
        "",
        f"- rows: {total_rows}",
        "- metadata columns: `text`, `video`, `hard_negative_texts`, `hard_negative_videos`",
        "- positive text: query 1 (`__full__00`) from the source row",
        f"- hard negatives per row: {NEGATIVE_COUNT}",
        "- video paths: repository-relative `videos/<family>/<case_id>.mp4`",
        "- list alignment: `hard_negative_texts[i]` and `hard_negative_videos[i]` come from the same case",
        "- candidate pool: only the other 99 cases in the positive case's high-level fluid family",
        "",
        "## Reproducibility",
        "",
        f"- global seed: {seed}",
        "- traversal: family alphabetical order, then case_id order",
        f"- sampling: one `random.Random(seed)` stream for all {total_rows} rows",
        "- selection: `random.sample(sorted(other_99_case_ids), 5)`",
        f"- high-level fluid families: {family_count}",
        "",
        "## Loading",
        "",
        "```python",
        "from pathlib import Path",
        "import pyarrow.parquet as pq",
        "from huggingface_hub import snapshot_download",
        "",
        f"root = Path(snapshot_download(\"{repo_id}\", repo_type=\"dataset\"))",
        "rows = pq.read_table(root / \"metadata.parquet\").to_pylist()",
        "row = rows[0]",
        "positive_video = root / row[\"video\"]",
        "negative_videos = [root / path for path in row[\"hard_negative_videos\"]]",
        "```",
        "",
        "The training metadata intentionally contains only the four requested columns. Case IDs, query IDs, and sampled assignments are retained in `source_metadata/sampling_manifest.json` for auditing.",
        "",
    ]
    return "\n".join(lines)


def _validate_output(
    *,
    out_dir: Path,
    metadata_rows: list[dict[str, Any]],
    family_rows: dict[str, list[dict[str, Any]]],
    expected_total_rows: int,
    source_video_hash: str,
) -> dict[str, Any]:
    errors: list[str] = []
    table = pq.read_table(out_dir / "metadata.parquet")
    if tuple(table.column_names) != OUTPUT_COLUMNS:
        errors.append(f"metadata columns are {table.column_names}, expected {OUTPUT_COLUMNS}")
    written_rows = table.to_pylist()
    if len(written_rows) != expected_total_rows:
        errors.append(f"metadata has {len(written_rows)} rows, expected {expected_total_rows}")
    if written_rows != metadata_rows:
        errors.append("metadata changed during parquet serialization")

    source_by_path: dict[str, dict[str, Any]] = {}
    source_by_case: dict[str, tuple[str, dict[str, Any]]] = {}
    for family, rows in family_rows.items():
        for row in rows:
            case_id = str(row["case_id"])
            source_by_path[_video_relpath(family, case_id)] = row
            source_by_case[case_id] = (family, row)

    output_digest = hashlib.sha256()
    seen_positive_paths: set[str] = set()
    hard_negative_pairs = 0
    cross_family_count = 0
    self_negative_count = 0
    for row in written_rows:
        video = str(row["video"])
        source = source_by_path.get(video)
        if source is None:
            errors.append(f"positive video path is unknown: {video}")
            continue
        family = Path(video).parts[1]
        if video in seen_positive_paths:
            errors.append(f"duplicate positive video path: {video}")
        seen_positive_paths.add(video)
        if str(row["text"]) != str(source["raw_text"]):
            errors.append(f"positive text mismatch: {video}")
        neg_texts = list(row["hard_negative_texts"])
        neg_videos = [str(path) for path in row["hard_negative_videos"]]
        if len(neg_texts) != NEGATIVE_COUNT or len(neg_videos) != NEGATIVE_COUNT:
            errors.append(f"{video}: expected five hard negatives")
        if len(set(neg_videos)) != NEGATIVE_COUNT:
            errors.append(f"{video}: hard-negative videos are not unique")
        for neg_text, neg_video in zip(neg_texts, neg_videos):
            hard_negative_pairs += 1
            neg_source = source_by_path.get(neg_video)
            if neg_source is None:
                errors.append(f"{video}: unknown hard-negative path {neg_video}")
                continue
            if Path(neg_video).parts[1] != family:
                cross_family_count += 1
            if neg_video == video:
                self_negative_count += 1
            if str(neg_text) != str(neg_source["raw_text"]):
                errors.append(f"{video}: hard-negative text/path mismatch for {neg_video}")

    if cross_family_count:
        errors.append(f"found {cross_family_count} cross-family hard negatives")
    if self_negative_count:
        errors.append(f"found {self_negative_count} self hard negatives")

    missing_videos: list[str] = []
    for relpath in sorted(source_by_path):
        path = out_dir / relpath
        if not path.is_file() or path.stat().st_size == 0:
            missing_videos.append(relpath)
            continue
        _update_video_digest(output_digest, relpath, path.read_bytes())
    output_video_hash = output_digest.hexdigest()
    if output_video_hash != source_video_hash:
        errors.append("video bytes changed while creating the VideoFolder")

    return {
        "passed": not errors,
        "errors": errors[:100],
        "metadata_rows": len(written_rows),
        "metadata_columns": table.column_names,
        "video_files": len(source_by_path) - len(missing_videos),
        "missing_videos": missing_videos[:100],
        "hard_negative_pairs": hard_negative_pairs,
        "cross_family_hard_negatives": cross_family_count,
        "self_hard_negatives": self_negative_count,
        "source_video_sha256": source_video_hash,
        "output_video_sha256": output_video_hash,
        "video_bytes_preserved": source_video_hash == output_video_hash,
    }


def build_dataset(
    *,
    source_dir: Path,
    cases_jsonl: Path,
    out_dir: Path,
    repo_id: str,
    source_repo: str,
    seed: int,
    expected_rows_per_family: int,
    expected_total_rows: int,
) -> dict[str, Any]:
    if out_dir.exists() and any(out_dir.iterdir()):
        raise FileExistsError(f"Output directory is not empty: {out_dir}")
    case_to_family = _case_family_map(cases_jsonl)
    family_rows = _read_source_full_rows(source_dir, case_to_family)
    bad_counts = {family: len(rows) for family, rows in family_rows.items() if len(rows) != expected_rows_per_family}
    if bad_counts:
        raise ValueError(f"Expected {expected_rows_per_family} rows per high-level family: {bad_counts}")
    if sum(map(len, family_rows.values())) != expected_total_rows:
        raise ValueError(f"Expected {expected_total_rows} rows in total")

    assignments = _sample_assignments(family_rows, seed=seed)
    repeated = _sample_assignments(family_rows, seed=seed)
    if assignments != repeated:
        raise AssertionError("Hard-negative sampling is not reproducible")

    out_dir.mkdir(parents=True, exist_ok=True)
    metadata_rows: list[dict[str, Any]] = []
    manifest_rows: list[dict[str, Any]] = []
    source_video_digest = hashlib.sha256()
    video_size = 0

    for family in sorted(family_rows):
        rows = family_rows[family]
        by_case = {str(row["case_id"]): row for row in rows}
        for source_row in rows:
            case_id = str(source_row["case_id"])
            query_id = str(source_row["query_id"])
            relpath = _video_relpath(family, case_id)
            video_bytes = _video_bytes(source_row)
            video_path = out_dir / relpath
            video_path.parent.mkdir(parents=True, exist_ok=True)
            video_path.write_bytes(video_bytes)
            video_size += len(video_bytes)
            _update_video_digest(source_video_digest, relpath, video_bytes)

            negative_case_ids = assignments[family][case_id]
            negative_rows = [by_case[negative_id] for negative_id in negative_case_ids]
            negative_paths = [_video_relpath(family, negative_id) for negative_id in negative_case_ids]
            metadata_rows.append(
                {
                    "text": str(source_row["raw_text"]),
                    "video": relpath,
                    "hard_negative_texts": [str(row["raw_text"]) for row in negative_rows],
                    "hard_negative_videos": negative_paths,
                }
            )
            manifest_rows.append(
                {
                    "family": family,
                    "case_id": case_id,
                    "query_id": query_id,
                    "video": relpath,
                    "negative_case_ids": negative_case_ids,
                    "negative_query_ids": [str(row["query_id"]) for row in negative_rows],
                    "hard_negative_videos": negative_paths,
                }
            )

    metadata_path = out_dir / "metadata.parquet"
    table = pa.Table.from_pylist(metadata_rows, schema=OUTPUT_SCHEMA)
    pq.write_table(table, metadata_path, compression="snappy", row_group_size=100, write_page_index=True)
    source_video_hash = source_video_digest.hexdigest()
    validation = _validate_output(
        out_dir=out_dir,
        metadata_rows=metadata_rows,
        family_rows=family_rows,
        expected_total_rows=expected_total_rows,
        source_video_hash=source_video_hash,
    )
    validation.update(
        {
            "repo_id": repo_id,
            "source_repo": source_repo,
            "seed": seed,
            "family_count": len(family_rows),
            "rows_per_family": {family: len(rows) for family, rows in family_rows.items()},
            "assignment_sha256": _assignment_digest(assignments),
            "second_pass_assignment_sha256": _assignment_digest(repeated),
            "reproducibility_verified": assignments == repeated,
            "single_rng_stream": True,
            "traversal_order": "family alphabetical, then case_id",
        }
    )
    _write_json(out_dir / "quality" / "validation.json", validation)
    _write_json(
        out_dir / "generation_manifest.json",
        {
            "repo_id": repo_id,
            "source_repo": source_repo,
            "seed": seed,
            "algorithm": "one random.Random(seed) stream; sorted high-level families; sorted case_id; random.sample(sorted(other_99_case_ids), 5)",
            "family_count": len(family_rows),
            "total_rows": len(metadata_rows),
            "assignment_sha256": _assignment_digest(assignments),
        },
    )
    _write_json(out_dir / "source_metadata" / "sampling_manifest.json", manifest_rows)
    _write_json(out_dir / "source_metadata" / "family_case_counts.json", {family: len(rows) for family, rows in family_rows.items()})
    shutil.copy2(cases_jsonl, out_dir / "source_metadata" / "cases.jsonl")
    shutil.copy2(Path(__file__).resolve(), out_dir / "source_metadata" / "build_hf_hardneg_dataset.py")
    (out_dir / ".gitattributes").write_text("*.mp4 filter=lfs diff=lfs merge=lfs -text\n", encoding="utf-8")
    (out_dir / "README.md").write_text(
        _readme(
            repo_id=repo_id,
            source_repo=source_repo,
            seed=seed,
            total_rows=len(metadata_rows),
            metadata_size=metadata_path.stat().st_size,
            video_size=video_size,
            family_count=len(family_rows),
        ),
        encoding="utf-8",
    )
    if not validation["passed"]:
        raise ValueError(f"Validation failed: {validation['errors'][:10]}")
    return validation


def main() -> None:
    parser = argparse.ArgumentParser(description="Build path-based fluid hard-negative VideoFolder data.")
    parser.add_argument("--source-dir", type=Path, required=True, help="Previewable HF source layout with scenario/train-*.parquet files.")
    parser.add_argument("--cases-jsonl", type=Path, required=True, help="cases.jsonl containing high-level family for each case.")
    parser.add_argument("--out-dir", type=Path, required=True)
    parser.add_argument("--repo-id", default="gowitheflowlab/physics-bench-fluid-w-hardnegs")
    parser.add_argument("--source-repo", default="gowitheflowlab/physics-bench-fluid-train-700")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--expected-rows-per-family", type=int, default=100)
    parser.add_argument("--expected-total-rows", type=int, default=700)
    args = parser.parse_args()
    result = build_dataset(
        source_dir=args.source_dir.resolve(),
        cases_jsonl=args.cases_jsonl.resolve(),
        out_dir=args.out_dir.resolve(),
        repo_id=args.repo_id,
        source_repo=args.source_repo,
        seed=args.seed,
        expected_rows_per_family=args.expected_rows_per_family,
        expected_total_rows=args.expected_total_rows,
    )
    print(json.dumps(result, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()