Resolve eval sources from dataset manifests

benchmarks/edit/build_six_method_manifest.py

@@ -4,8 +4,10 @@
 from __future__ import annotations
 
 import argparse
+from collections import defaultdict
 import json
 from pathlib import Path
+from typing import Any
 
 
 METHODS = ("wan_only", "ditto_global", "full", "text", "vace_hint", "vace_context")
@@ -53,13 +55,61 @@ def load_source_maps(paths: list[Path], repo_root: Path) -> tuple[dict[str, Path
     return by_id, by_key
 
 
+def dataset_name_from_path(path: str) -> str:
+    parts = Path(path).parts
+    for index, part in enumerate(parts):
+        if part == "datas" and index + 1 < len(parts):
+            return parts[index + 1]
+    return ""
+
+
+def target_bucket_from_path(path: str) -> str:
+    stem = Path(path).stem
+    if "__" in stem:
+        return stem.split("__", 1)[0]
+    if "/" in path:
+        parts = Path(path).parts
+        if "high" in parts:
+            index = parts.index("high")
+            if index + 1 < len(parts):
+                return parts[index + 1]
+    return ""
+
+
+def edit_index_from_path(path: str) -> str:
+    stem = Path(path).stem
+    if "_" not in stem:
+        return ""
+    tail = stem.rsplit("_", 1)[-1]
+    return tail if tail.isdigit() else ""
+
+
+def load_dataset_manifests(paths: list[Path], repo_root: Path) -> dict[tuple[str, str, str], list[dict[str, Any]]]:
+    by_dataset_bucket_prompt: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for path in paths:
+        path = path if path.is_absolute() else repo_root / path
+        if not path.exists():
+            continue
+        dataset = path.parent.name
+        rows = json.loads(path.read_text(encoding="utf-8"))
+        for row in rows:
+            bucket = str(row.get("target_bucket", ""))
+            prompt = str(row.get("prompt", ""))
+            if dataset and bucket and prompt:
+                by_dataset_bucket_prompt[(dataset, bucket, prompt)].append(row)
+    return by_dataset_bucket_prompt
+
+
 def resolve_source_video(
     repo_root: Path,
     sample_id: str,
     raw_path: str,
+    target_path: str,
+    prompt: str,
     source_roots: list[Path],
     source_by_id: dict[str, Path],
     source_by_key: dict[str, Path],
+    dataset_rows: dict[tuple[str, str, str], list[dict[str, Any]]],
 ) -> Path:
     if sample_id in source_by_id:
         return source_by_id[sample_id]
@@ -69,6 +119,29 @@ def resolve_source_video(
     if raw_name in source_by_key:
         return source_by_key[raw_name]
 
+    dataset = dataset_name_from_path(target_path) or dataset_name_from_path(raw_path)
+    bucket = target_bucket_from_path(target_path)
+    rows = dataset_rows.get((dataset, bucket, prompt), [])
+    if rows:
+        edit_index = edit_index_from_path(target_path)
+        if edit_index:
+            indexed_rows = [
+                row
+                for row in rows
+                if Path(str(row.get("high_materialized") or row.get("high_video_path") or row.get("high_rel") or "")).stem.endswith(
+                    f"_{edit_index}"
+                )
+            ]
+            if len(indexed_rows) == 1:
+                rows = indexed_rows
+        if len(rows) == 1:
+            manifest_source = rows[0].get("low_materialized") or rows[0].get("low_video_path")
+            if manifest_source:
+                source_from_manifest = Path(str(manifest_source))
+                if not source_from_manifest.is_absolute():
+                    source_from_manifest = repo_root / source_from_manifest
+                return source_from_manifest
+
     source_video = Path(raw_path)
     if not source_video.is_absolute():
         source_video = repo_root / source_video
@@ -101,6 +174,7 @@ def build_split(
     source_roots: list[Path],
     source_by_id: dict[str, Path],
     source_by_key: dict[str, Path],
+    dataset_rows: dict[tuple[str, str, str], list[dict[str, Any]]],
 ) -> None:
     samples = read_jsonl(samples_path)
     output_path.parent.mkdir(parents=True, exist_ok=True)
@@ -114,9 +188,12 @@ def build_split(
                 repo_root,
                 sample_id,
                 str(sample["control_video"]),
+                str(sample.get("target_video", "")),
+                str(sample["prompt"]),
                 source_roots,
                 source_by_id,
                 source_by_key,
+                dataset_rows,
             )
             if not source_video.exists():
                 missing_sources.add(str(source_video))
@@ -168,12 +245,24 @@ def main() -> None:
             "It can also contain old_path/old_video/control_video to map old names to current hashed paths."
         ),
     )
+    parser.add_argument(
+        "--dataset-manifest",
+        type=Path,
+        action="append",
+        default=[],
+        help="Dataset manifest.json used to map eval_samples target_video/prompt back to hash low_materialized paths.",
+    )
     args = parser.parse_args()
 
     repo_root = args.repo_root.resolve()
     base = repo_root / "out/edit_model_face_stage1"
     output_dir = args.output_dir if args.output_dir.is_absolute() else repo_root / args.output_dir
     source_by_id, source_by_key = load_source_maps(args.source_map, repo_root)
+    dataset_manifest_paths = args.dataset_manifest or [
+        Path("datas/ditto_face/manifest.json"),
+        Path("datas/ditto_face2/manifest.json"),
+    ]
+    dataset_rows = load_dataset_manifests(dataset_manifest_paths, repo_root)
 
     jobs = [
         (
@@ -201,6 +290,7 @@ def main() -> None:
             args.source_root,
             source_by_id,
             source_by_key,
+            dataset_rows,
         )