| |
| """Generate one deterministic shard of the StatePlay proxy benchmark.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import sys |
| from pathlib import Path |
|
|
| import imageio.v3 as iio |
| import numpy as np |
| import torch |
| from PIL import Image |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| if str(ROOT) not in sys.path: |
| sys.path.insert(0, str(ROOT)) |
|
|
| from stateplay import NEG_PROMPT, StatePlayPipeline |
| from stateplay.utils import save_mp4 |
|
|
|
|
| def first_video_frame(path: Path) -> Image.Image: |
| try: |
| frame = next(iio.imiter(path, plugin="FFMPEG")) |
| except StopIteration as exc: |
| raise RuntimeError(f"Video contains no frames: {path}") from exc |
| return Image.fromarray(np.asarray(frame, dtype=np.uint8)).convert("RGB") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--manifest", type=Path, default=ROOT / "evaluation/proxy100/selection.json") |
| parser.add_argument("--checkpoint", type=Path, required=True) |
| parser.add_argument("--run-name", required=True) |
| parser.add_argument("--base-model", type=Path, default=ROOT / "base_model") |
| parser.add_argument("--output-root", type=Path, default=ROOT / "evaluation/proxy100/generated") |
| parser.add_argument("--device", default="cuda") |
| parser.add_argument("--shard-index", type=int, default=0) |
| parser.add_argument("--num-shards", type=int, default=1) |
| parser.add_argument("--only", nargs="*") |
| parser.add_argument("--skip-existing", action="store_true") |
| parser.add_argument("--steps", type=int, default=30) |
| parser.add_argument("--cfg", type=float, default=5.0) |
| parser.add_argument("--action-cfg", type=float, default=1.0) |
| parser.add_argument("--seed", type=int, default=2) |
| args = parser.parse_args() |
|
|
| if not 0 <= args.shard_index < args.num_shards: |
| raise ValueError("--shard-index must be in [0, --num-shards)") |
| data = json.loads(args.manifest.resolve().read_text(encoding="utf-8")) |
| all_samples = data["samples"] |
| selected = [sample for index, sample in enumerate(all_samples) if index % args.num_shards == args.shard_index] |
| if args.only: |
| wanted = set(args.only) |
| selected = [sample for sample in selected if sample["id"] in wanted or sample["source_id"] in wanted] |
| if not selected: |
| print(f"Shard {args.shard_index} has no selected samples", flush=True) |
| return |
|
|
| output_dir = (args.output_root / args.run_name).resolve() |
| output_dir.mkdir(parents=True, exist_ok=True) |
| print(f"Loading {args.checkpoint} for shard {args.shard_index}/{args.num_shards} ({len(selected)} samples)", flush=True) |
| pipeline = StatePlayPipeline.from_pretrained( |
| base_model_dir=str(args.base_model.resolve()), |
| checkpoint_path=str(args.checkpoint.resolve()), |
| torch_dtype=torch.bfloat16, |
| ).to(args.device) |
|
|
| records = [] |
| for position, sample in enumerate(selected, start=1): |
| output = output_dir / sample["output_name"] |
| state_output = output.with_name(f"{output.stem}_state.txt") |
| if args.skip_existing and output.is_file() and output.stat().st_size > 0: |
| print(f"[{position}/{len(selected)}] skip {sample['id']} {output.name}", flush=True) |
| continue |
| if sample.get("input_image"): |
| with Image.open(ROOT / sample["input_image"]) as source: |
| image = source.convert("RGB") |
| else: |
| image = first_video_frame(ROOT / sample["source_video"]) |
| result = pipeline( |
| image=image, |
| actions_parquet=str(ROOT / sample["actions"]), |
| state_parquet=str(ROOT / sample["actions"]), |
| state_txt=None if pipeline.uses_latent_state else str(state_output), |
| state_sampling="end", |
| prompt=sample["prompt"], |
| negative_prompt=NEG_PROMPT, |
| num_frames=101, |
| num_inference_steps=args.steps, |
| cfg_scale=args.cfg, |
| state_cfg_scale=1.0, |
| action_cfg_scale=args.action_cfg, |
| seed=args.seed, |
| ) |
| temporary = output.with_name(f"{output.stem}.tmp.mp4") |
| save_mp4(result.frames[0], str(temporary), fps=20) |
| temporary.replace(output) |
| records.append( |
| { |
| "id": sample["id"], |
| "source_id": sample["source_id"], |
| "label": sample["label"], |
| "output": os.path.relpath(output, ROOT), |
| "state_output": None if pipeline.uses_latent_state else os.path.relpath(state_output, ROOT), |
| } |
| ) |
| print(f"[{position}/{len(selected)}] saved {sample['id']} {output}", flush=True) |
|
|
| record_path = output_dir / f"run_manifest_shard_{args.shard_index:02d}.json" |
| record_path.write_text(json.dumps(records, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
