| |
| """Build a reproducible 100-sample StatePlay in-sample proxy benchmark.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import random |
| from collections import Counter |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| LABELS = ("normal", "macro_success", "macro_fail", "result_win", "result_lose") |
|
|
|
|
| def sha256_bytes(data: bytes) -> str: |
| return hashlib.sha256(data).hexdigest() |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def repo_path(path: Path) -> str: |
| return path.resolve().relative_to(ROOT).as_posix() |
|
|
|
|
| def normalize_label(value: str) -> str: |
| label = value.strip().lower().replace("-", "_").replace(" ", "_") |
| if label not in LABELS: |
| raise ValueError(f"Unsupported distribution label: {value!r}") |
| return label |
|
|
|
|
| def bundled_examples(examples_manifest: Path) -> list[dict[str, Any]]: |
| result = [] |
| with examples_manifest.open(newline="", encoding="utf-8-sig") as handle: |
| rows = list(csv.DictReader(handle)) |
| for row in rows: |
| input_dir = examples_manifest.parent / row["input_dir"] |
| metadata_path = input_dir / "metadata.json" |
| metadata = json.loads(metadata_path.read_text(encoding="utf-8")) |
| prompt_path = input_dir / "prompt.txt" |
| actions_path = input_dir / "actions.parquet" |
| image_path = input_dir / "first_frame.png" |
| prompt = prompt_path.read_text(encoding="utf-8").strip() |
| result.append( |
| { |
| "source_kind": "bundled_external", |
| "source_id": f"example_{row['id'].zfill(2)}", |
| "label": normalize_label(metadata["distribution"]), |
| "input_image": repo_path(image_path), |
| "source_video": None, |
| "reference_video": None, |
| "actions": repo_path(actions_path), |
| "prompt": prompt, |
| "identity": { |
| "input_image_sha256": sha256_file(image_path), |
| "actions_sha256": sha256_file(actions_path), |
| "prompt_sha256": sha256_bytes(prompt.encode("utf-8")), |
| "metadata_sha256": sha256_file(metadata_path), |
| }, |
| } |
| ) |
| return result |
|
|
|
|
| def training_examples( |
| metadata_path: Path, |
| existing: list[dict[str, Any]], |
| per_class: int, |
| seed: int, |
| ) -> list[dict[str, Any]]: |
| with metadata_path.open(newline="", encoding="utf-8-sig") as handle: |
| rows = list(csv.DictReader(handle)) |
| by_label: dict[str, list[dict[str, str]]] = {label: [] for label in LABELS} |
| for row in rows: |
| by_label[normalize_label(row["distribution"])].append(row) |
|
|
| existing_counts = Counter(item["label"] for item in existing) |
| rng = random.Random(seed) |
| selected: list[dict[str, Any]] = [] |
| data_root = metadata_path.parent |
| for label in LABELS: |
| needed = per_class - existing_counts[label] |
| if needed < 0: |
| raise ValueError(f"Bundled examples exceed target count for {label}: {existing_counts[label]} > {per_class}") |
| candidates = sorted(by_label[label], key=lambda row: row["video"]) |
| if len(candidates) < needed: |
| raise ValueError(f"Not enough {label} candidates: need {needed}, found {len(candidates)}") |
| for row in rng.sample(candidates, needed): |
| video_path = data_root / row["video"] |
| actions_path = data_root / row["action"] |
| clip_id = video_path.parent.name |
| prompt = row["prompt"].strip() |
| selected.append( |
| { |
| "source_kind": "training_clip", |
| "source_id": clip_id, |
| "label": label, |
| "input_image": None, |
| "source_video": repo_path(video_path), |
| "reference_video": repo_path(video_path), |
| "actions": repo_path(actions_path), |
| "prompt": prompt, |
| "identity": { |
| "video_sha256": sha256_file(video_path), |
| "video_size": video_path.stat().st_size, |
| "actions_sha256": sha256_file(actions_path), |
| "prompt_sha256": sha256_bytes(prompt.encode("utf-8")), |
| "metadata_video": row["video"], |
| "metadata_action": row["action"], |
| }, |
| } |
| ) |
| return selected |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--metadata", type=Path, default=ROOT / "data/SF3/train/clips_5s/metadata_state_polish.csv") |
| parser.add_argument("--examples-manifest", type=Path, default=ROOT / "examples/manifest.csv") |
| parser.add_argument("--output-dir", type=Path, default=ROOT / "evaluation/proxy100") |
| parser.add_argument("--seed", type=int, default=260726754) |
| parser.add_argument("--per-class", type=int, default=20) |
| args = parser.parse_args() |
|
|
| bundled = bundled_examples(args.examples_manifest.resolve()) |
| training = training_examples(args.metadata.resolve(), bundled, args.per_class, args.seed) |
| samples = bundled + training |
| samples.sort(key=lambda item: (LABELS.index(item["label"]), item["source_kind"], item["source_id"])) |
| for index, sample in enumerate(samples, start=1): |
| sample["id"] = f"proxy_{index:03d}" |
| sample["output_name"] = f"proxy_{index:03d}_{sample['label']}_{sample['source_id']}.mp4" |
|
|
| counts = Counter(item["label"] for item in samples) |
| expected_total = args.per_class * len(LABELS) |
| if len(samples) != expected_total or any(counts[label] != args.per_class for label in LABELS): |
| raise RuntimeError(f"Invalid selection: total={len(samples)}, counts={dict(counts)}") |
|
|
| output_dir = args.output_dir.resolve() |
| output_dir.mkdir(parents=True, exist_ok=True) |
| manifest = { |
| "benchmark_name": "stateplay_proxy100_mixed_v1", |
| "warning": "Mixed proxy benchmark: 92 in-sample training clips plus 8 bundled external examples; not the unpublished 100-clip held-out paper test set.", |
| "selection": { |
| "seed": args.seed, |
| "labels": list(LABELS), |
| "per_class": args.per_class, |
| "total": len(samples), |
| "bundled_external": len(bundled), |
| "training_clips": len(training), |
| "metadata": repo_path(args.metadata.resolve()), |
| "metadata_sha256": sha256_file(args.metadata.resolve()), |
| }, |
| "samples": samples, |
| } |
| json_path = output_dir / "selection.json" |
| json_path.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
| columns = ("id", "source_kind", "source_id", "label", "input_image", "source_video", "reference_video", "actions", "output_name") |
| with (output_dir / "selection.csv").open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=columns) |
| writer.writeheader() |
| for sample in samples: |
| writer.writerow({key: sample.get(key) or "" for key in columns}) |
| print(json.dumps({"manifest": str(json_path), "counts": dict(counts), "sources": dict(Counter(x["source_kind"] for x in samples))}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
