Add eval sample builder for valN

benchmarks/edit/build_eval_samples.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Build val_N eval sample jsonl files from Ditto manifests.
+
+The output schema matches the saved val20/val100 artifacts:
+{"id", "target_video", "control_video", "prompt"}.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_MANIFESTS = (
+    "datas/ditto_face/manifest.json",
+    "datas/ditto_face2/manifest.json",
+)
+
+DEFAULT_BUCKET_PREFIXES = (
+    "global_freeform1",
+    "global_freeform1_filtered",
+    "global_freeform2",
+    "global_freeform2_filtered",
+    "global_freeform3",
+    "global_style1",
+    "global_style2",
+)
+
+
+def read_json(path: Path) -> list[dict[str, Any]]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, list):
+        raise TypeError(f"{path} must contain a JSON list")
+    return data
+
+
+def sanitize_flat_relpath(relpath: str) -> str:
+    parts = [re.sub(r"[^0-9A-Za-z._-]+", "_", piece) for piece in relpath.split("/")]
+    return "__".join(parts)
+
+
+def bucket_root(bucket: str) -> str:
+    return bucket.split("/", 1)[0]
+
+
+def category_from_relpath(relpath: str) -> str:
+    parts = Path(relpath).parts
+    return parts[1] if len(parts) >= 3 else ""
+
+
+def video_path(dataset: str, side: str, relpath: str, materialized: str, path_style: str) -> str:
+    if path_style == "materialized" and materialized:
+        return materialized
+    return str(Path("datas") / dataset / side / sanitize_flat_relpath(relpath))
+
+
+def row_to_sample(row: dict[str, Any], dataset: str, path_style: str) -> dict[str, str] | None:
+    prompt = str(row.get("prompt", "") or "").strip()
+    low_rel = str(row.get("low_rel", "") or row.get("low_video_relpath", "") or "")
+    high_rel = str(row.get("high_rel", "") or row.get("high_video_relpath", "") or "")
+    if not prompt or not low_rel or not high_rel:
+        return None
+    return {
+        "target_video": video_path(dataset, "high", high_rel, str(row.get("high_materialized", "") or ""), path_style),
+        "control_video": video_path(dataset, "low", low_rel, str(row.get("low_materialized", "") or ""), path_style),
+        "prompt": prompt,
+        "_dataset": dataset,
+        "_bucket": bucket_root(str(row.get("target_bucket", "") or high_rel.split("/", 1)[0])),
+        "_category": category_from_relpath(high_rel),
+        "_dedupe_key": f"{dataset}\n{low_rel}\n{prompt}",
+    }
+
+
+def collect_candidates(
+    repo_root: Path,
+    manifests: list[Path],
+    bucket_prefixes: tuple[str, ...],
+    path_style: str,
+) -> list[dict[str, str]]:
+    candidates = []
+    seen = set()
+    for manifest in manifests:
+        path = manifest if manifest.is_absolute() else repo_root / manifest
+        dataset = path.parent.name
+        for row in read_json(path):
+            bucket = bucket_root(str(row.get("target_bucket", "") or ""))
+            if bucket and bucket not in bucket_prefixes:
+                continue
+            sample = row_to_sample(row, dataset, path_style)
+            if sample is None:
+                continue
+            key = sample["_dedupe_key"]
+            if key in seen:
+                continue
+            seen.add(key)
+            candidates.append(sample)
+    return candidates
+
+
+def stratified_sample(candidates: list[dict[str, str]], count: int, seed: int) -> list[dict[str, str]]:
+    rng = random.Random(seed)
+    buckets: dict[tuple[str, str, str], list[dict[str, str]]] = defaultdict(list)
+    for sample in candidates:
+        buckets[(sample["_dataset"], sample["_bucket"], sample["_category"])].append(sample)
+    for values in buckets.values():
+        rng.shuffle(values)
+
+    queues = list(buckets.values())
+    rng.shuffle(queues)
+    selected = []
+    while queues and len(selected) < count:
+        next_queues = []
+        for queue in queues:
+            if len(selected) >= count:
+                break
+            if queue:
+                selected.append(queue.pop())
+            if queue:
+                next_queues.append(queue)
+        queues = next_queues
+        rng.shuffle(queues)
+    if len(selected) < count:
+        raise RuntimeError(f"only selected {len(selected)} samples from {len(candidates)} candidates")
+    return selected[:count]
+
+
+def write_samples(path: Path, samples: list[dict[str, str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        for index, sample in enumerate(samples):
+            row = {
+                "id": f"val_{index:04d}",
+                "target_video": sample["target_video"],
+                "control_video": sample["control_video"],
+                "prompt": sample["prompt"],
+            }
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--repo-root", type=Path, default=Path.cwd())
+    parser.add_argument("--manifest", type=Path, action="append", default=[])
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--count", type=int, default=1000)
+    parser.add_argument("--seed", type=int, default=20260511)
+    parser.add_argument("--path-style", choices=("flat", "materialized"), default="flat")
+    parser.add_argument("--bucket-prefix", action="append", default=[])
+    args = parser.parse_args()
+
+    manifests = args.manifest or [Path(p) for p in DEFAULT_MANIFESTS]
+    bucket_prefixes = tuple(args.bucket_prefix or DEFAULT_BUCKET_PREFIXES)
+    candidates = collect_candidates(args.repo_root, manifests, bucket_prefixes, args.path_style)
+    selected = stratified_sample(candidates, args.count, args.seed)
+    write_samples(args.output, selected)
+    print(f"candidates={len(candidates)}")
+    print(f"selected={len(selected)} -> {args.output}")
+    print(f"path_style={args.path_style}, seed={args.seed}")
+
+
+if __name__ == "__main__":
+    main()