| |
|
|
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import os |
| import subprocess |
| import sys |
| import threading |
| import queue |
| from pathlib import Path |
|
|
|
|
| REPO_ROOT = Path(__file__).resolve().parents[1] |
|
|
|
|
| def collect_samples( |
| data_root: Path, |
| models: list[str], |
| only: set[str] | None, |
| default_mode: str, |
| *, |
| mode_by_sample: dict[str, str] | None = None, |
| allow_missing_models: bool = False, |
| ) -> list[tuple[str, str]]: |
| gt_root = data_root / "gt" |
| if not gt_root.is_dir(): |
| raise FileNotFoundError(f"ground-truth directory missing: {gt_root}") |
|
|
| out: list[tuple[str, str]] = [] |
| missing_gt = sorted(only - {d.name for d in gt_root.iterdir() if d.is_dir()}) if only else [] |
| if missing_gt: |
| preview = ", ".join(missing_gt[:10]) |
| raise FileNotFoundError(f"track manifest references missing GT samples: {preview}") |
|
|
| missing_models: list[str] = [] |
| for d in sorted(gt_root.iterdir()): |
| if not d.is_dir(): |
| continue |
| sid = d.name |
| if only is not None and sid not in only: |
| continue |
| if not _has_scene(d): |
| raise FileNotFoundError(f"GT geometry missing for sample {sid}: {d}") |
|
|
| missing = [model for model in models if not _has_scene(data_root / model / sid)] |
| if missing and not allow_missing_models: |
| missing_models.append(f"{sid}: {','.join(missing)}") |
| continue |
|
|
| mode = (mode_by_sample or {}).get(sid, default_mode) |
| out.append((sid, mode)) |
|
|
| if missing_models: |
| preview = "; ".join(missing_models[:10]) |
| suffix = "" if len(missing_models) <= 10 else f"; ... and {len(missing_models) - 10} more" |
| raise FileNotFoundError(f"requested model geometry is incomplete: {preview}{suffix}") |
| return out |
|
|
|
|
| def load_track_manifest_sample_ids(manifest_path: Path) -> set[str]: |
| if not manifest_path.is_file(): |
| raise FileNotFoundError(f"track manifest missing: {manifest_path}") |
|
|
| def rows_from_payload(payload): |
| if isinstance(payload, list): |
| return payload |
| if isinstance(payload, dict): |
| samples = payload.get("samples") |
| if isinstance(samples, list): |
| return samples |
| return [payload] |
| raise ValueError(f"Unsupported manifest payload: {manifest_path}") |
|
|
| rows = [] |
| if manifest_path.suffix.lower() == ".jsonl": |
| for line_no, line in enumerate(manifest_path.read_text(encoding="utf-8").splitlines(), start=1): |
| raw = line.strip() |
| if not raw: |
| continue |
| obj = json.loads(raw) |
| if not isinstance(obj, dict): |
| raise ValueError(f"Expected JSON object at {manifest_path}:{line_no}") |
| rows.append(obj) |
| else: |
| rows = rows_from_payload(json.loads(manifest_path.read_text(encoding="utf-8"))) |
|
|
| sample_ids: set[str] = set() |
| for idx, row in enumerate(rows, start=1): |
| if not isinstance(row, dict): |
| raise ValueError(f"Expected JSON object at {manifest_path}:{idx}") |
| sid = row.get("sample_id") or row.get("id") |
| if not sid: |
| raise ValueError(f"Missing sample_id/id at {manifest_path}:{idx}") |
| sample_ids.add(str(sid)) |
| return sample_ids |
|
|
|
|
| def load_track_manifest_modes(manifest_path: Path, default_mode: str) -> dict[str, str]: |
| modes: dict[str, str] = {} |
| lines = manifest_path.read_text(encoding="utf-8").splitlines() |
| if manifest_path.suffix.lower() == ".jsonl": |
| rows = [json.loads(line) for line in lines if line.strip()] |
| else: |
| payload = json.loads("\n".join(lines)) |
| rows = payload.get("samples", [payload]) if isinstance(payload, dict) else payload |
|
|
| for row in rows: |
| sid = row.get("sample_id") or row.get("id") |
| if not sid: |
| continue |
| mode = row.get("geometry_frame_mode") |
| if not mode and row.get("frame") is not None: |
| mode = f"exact:{int(row['frame'])}" |
| modes[str(sid)] = str(mode or default_mode) |
| return modes |
|
|
|
|
| SCENE_EXTS = (".glb", ".blend", ".gltf") |
|
|
|
|
| def _has_scene(model_dir: Path) -> bool: |
| if not model_dir.is_dir(): |
| return False |
| for ext in SCENE_EXTS: |
| if (model_dir / f"scene{ext}").exists(): |
| return True |
|
|
| return any(model_dir.glob(f"*{ext}") for ext in SCENE_EXTS if list(model_dir.glob(f"*{ext}"))) |
|
|
|
|
| def _scene_path(model_dir: Path) -> Path | None: |
| for ext in SCENE_EXTS: |
| candidate = model_dir / f"scene{ext}" |
| if candidate.is_file(): |
| return candidate.resolve() |
| for ext in SCENE_EXTS: |
| matches = sorted(model_dir.glob(f"*{ext}")) if model_dir.is_dir() else [] |
| if matches: |
| return matches[0].resolve() |
| return None |
|
|
|
|
| def _run_config(sid: str, mode: str, models: list[str], args) -> dict: |
| data_root = Path(args.data_root).resolve() |
| scene_keys = ["gt", *models] |
| scenes = {} |
| for key in scene_keys: |
| scene = _scene_path(data_root / key / sid) |
| if scene is None: |
| continue |
| stat = scene.stat() |
| scenes[key] = { |
| "path": str(scene), |
| "size": stat.st_size, |
| "mtime_ns": stat.st_mtime_ns, |
| } |
| payload = { |
| "schema_version": 1, |
| "sample_id": sid, |
| "models": models, |
| "geometry_frame_mode": mode, |
| "alignment": args.alignment, |
| "ground_policy": args.ground_policy, |
| "blender_bin": args.blender_bin, |
| "clip_model_path": args.clip_model_path, |
| "clip_batch_size": args.clip_batch_size, |
| "resolution_x": args.resolution_x, |
| "resolution_y": args.resolution_y, |
| "render_samples": args.render_samples, |
| "render_engine": args.render_engine, |
| "scenes": scenes, |
| } |
| encoded = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8") |
| payload["fingerprint"] = hashlib.sha256(encoded).hexdigest() |
| return payload |
|
|
|
|
| def run_one(sid: str, mode: str, gpu: str, args) -> tuple[str, bool, str]: |
| out_dir = Path(args.out_root) / sid |
| final = out_dir / "reports" / "final_report.json" |
| config_path = out_dir / "run_config.json" |
| data_root = Path(args.data_root).resolve() |
| requested = [m.strip() for m in args.models.split(",") if m.strip()] |
| present = [m for m in requested if _has_scene(data_root / m / sid)] |
| missing = [m for m in requested if m not in present] |
| if missing and not args.allow_partial: |
| return sid, False, f"missing model geometry: {','.join(missing)}" |
| if not present: |
| return sid, False, "no model geometry" |
|
|
| config = _run_config(sid, mode, present, args) |
| if final.exists() and config_path.exists() and not args.force: |
| try: |
| previous = json.loads(config_path.read_text(encoding="utf-8")) |
| if previous.get("fingerprint") == config["fingerprint"]: |
| return sid, True, "cached (matching configuration)" |
| except Exception: |
| pass |
|
|
| models_arg = ",".join(present) |
| env = dict(os.environ) |
| env["CUDA_VISIBLE_DEVICES"] = gpu |
|
|
|
|
|
|
| tpw = str(args.threads_per_worker) |
| for var in ("OMP_NUM_THREADS", "OPENBLAS_NUM_THREADS", "MKL_NUM_THREADS", |
| "NUMEXPR_NUM_THREADS", "VECLIB_MAXIMUM_THREADS", "BLENDER_NUM_THREADS"): |
| env[var] = tpw |
| cmd = [ |
| sys.executable, "scripts/run_blend_glb_eval_pipeline.py", |
| "--sample_id", sid, |
| "--models", models_arg, |
| "--gt_key", "gt", |
| "--data_root", str(data_root), |
| "--blender_bin", args.blender_bin, |
| "--clip_model_path", args.clip_model_path, |
| "--clip_batch_size", str(args.clip_batch_size), |
| "--alignment", args.alignment, |
| "--ground_policy", args.ground_policy, |
| "--geometry_frame_mode", mode, |
| "--resolution_x", str(args.resolution_x), |
| "--resolution_y", str(args.resolution_y), |
| "--samples", str(args.render_samples), |
| "--render_engine", args.render_engine, |
| "--out_dir", str(out_dir), |
| ] |
| logf = out_dir / "pipeline.log" |
| out_dir.mkdir(parents=True, exist_ok=True) |
| with open(logf, "w") as fh: |
| proc = subprocess.run(cmd, cwd=REPO_ROOT, env=env, stdout=fh, |
| stderr=subprocess.STDOUT, text=True) |
| if proc.returncode == 0 and final.exists(): |
| config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8") |
| return sid, True, "ok" |
| return sid, False, f"rc={proc.returncode} (see {logf})" |
|
|
|
|
| def worker(wq: queue.Queue, gpu: str, args, results: list, lock: threading.Lock): |
| while True: |
| try: |
| sid, mode = wq.get_nowait() |
| except queue.Empty: |
| return |
| sid_, ok, msg = run_one(sid, mode, gpu, args) |
| if not ok and args.retries > 0: |
| sid_, ok, msg = run_one(sid, mode, gpu, args) |
| with lock: |
| results.append((sid_, ok, msg)) |
| n = len(results) |
| print(f"[gpu{gpu}] ({n}) {sid_}: {'OK' if ok else 'FAIL'} {msg}", flush=True) |
| wq.task_done() |
|
|
|
|
| def aggregate( |
| out_root: Path, |
| samples: list[tuple[str, str]], |
| models: list[str], |
| *, |
| allow_partial: bool = False, |
| ) -> dict: |
| rows = [] |
| missing_reports: list[str] = [] |
| for sid, _ in samples: |
| fr = out_root / sid / "reports" / "final_report.json" |
| if not fr.exists(): |
| missing_reports.append(sid) |
| continue |
| d = json.loads(fr.read_text()) |
| for s in d.get("summary", []): |
| rows.append({ |
| "sample_id": sid, |
| "model": s.get("model"), |
| "scene_aabb_iou": s.get("scene_aabb_iou_mean"), |
| "scene_obb_iou": s.get("scene_obb_iou_mean"), |
| "object_aabb_iou": s.get("object_aabb_iou_penalized_mean"), |
| "object_obb_iou": s.get("object_obb_iou_penalized_mean"), |
| "pl_score": s.get("rendered_pl_score_100"), |
| "n_clip_score": s.get("rendered_n_clip_score_100"), |
| "pl_raw": s.get("rendered_pl_raw"), |
| "n_clip_raw": s.get("rendered_n_clip_raw"), |
| }) |
|
|
| found_pairs = {(row["sample_id"], row["model"]) for row in rows} |
| expected_pairs = {(sid, model) for sid, _ in samples for model in models} |
| missing_pairs = sorted(expected_pairs - found_pairs) |
| if not allow_partial and (missing_reports or missing_pairs): |
| details = [] |
| if missing_reports: |
| details.append(f"missing reports={len(missing_reports)}") |
| if missing_pairs: |
| details.append(f"missing sample/model rows={len(missing_pairs)}") |
| raise RuntimeError("incomplete evaluation; " + ", ".join(details)) |
| csv_path = out_root / "results_per_sample.csv" |
| fields = ["sample_id", "model", "scene_aabb_iou", "scene_obb_iou", |
| "object_aabb_iou", "object_obb_iou", "pl_score", "n_clip_score", |
| "pl_raw", "n_clip_raw"] |
| with open(csv_path, "w", newline="") as fh: |
| w = csv.DictWriter(fh, fieldnames=fields) |
| w.writeheader() |
| w.writerows(rows) |
|
|
|
|
| means = {} |
| for m in models: |
| mr = [r for r in rows if r["model"] == m] |
| if not mr: |
| continue |
| def avg(k): |
| vals = [r[k] for r in mr if isinstance(r[k], (int, float))] |
| return sum(vals) / len(vals) if vals else None |
| pl_raw = avg("pl_raw") |
| n_clip_raw = avg("n_clip_raw") |
| means[m] = { |
| "n": len(mr), |
| "expected_n": len(samples), |
| "coverage": len(mr) / len(samples) if samples else 0.0, |
| "scene_aabb_iou": avg("scene_aabb_iou"), |
| "scene_obb_iou": avg("scene_obb_iou"), |
| "object_aabb_iou": avg("object_aabb_iou"), |
| "object_obb_iou": avg("object_obb_iou"), |
| "pl": 100.0 * pl_raw if pl_raw is not None else None, |
| "n_clip": 10.0 * n_clip_raw if n_clip_raw is not None else None, |
| "pl_raw": pl_raw, |
| "n_clip_raw": n_clip_raw, |
| "pl_score": avg("pl_score"), |
| "n_clip_score": avg("n_clip_score"), |
| } |
| payload = { |
| "schema_version": 1, |
| "complete": not missing_reports and not missing_pairs, |
| "sample_count": len(samples), |
| "models": models, |
| "metric_definitions": { |
| "pl": "100 * mean normalized RGB MSE; lower is better", |
| "n_clip": "10 * mean(1 - CLIPSim); lower is better", |
| "scene_aabb_iou": "scene union AABB IoU; higher is better", |
| "scene_obb_iou": "scene union OBB IoU; higher is better", |
| "object_aabb_iou": "Hungarian-matched object AABB IoU with count penalty; higher is better", |
| "object_obb_iou": "Hungarian-matched object OBB IoU with count penalty; higher is better", |
| }, |
| "missing_reports": missing_reports, |
| "missing_pairs": [{"sample_id": sid, "model": model} for sid, model in missing_pairs], |
| "results": means, |
| } |
| (out_root / "results_summary.json").write_text(json.dumps(payload, indent=2) + "\n") |
|
|
| print(f"\n=== aggregated {len(rows)} model-rows over {len({r['sample_id'] for r in rows})} samples ===") |
| print("%-10s %4s | %-9s %-9s %-9s %-9s | %-8s %-8s" % ( |
| "model", "n", "scn_aabb", "scn_obb", "obj_aabb", "obj_obb", "PL", "NCLIP")) |
| print("-" * 80) |
| for m, v in means.items(): |
| print("%-10s %4d | %-9.3f %-9.3f %-9.3f %-9.3f | %-8.2f %-8.2f" % ( |
| m, v["n"], v["scene_aabb_iou"] or 0, v["scene_obb_iou"] or 0, |
| v["object_aabb_iou"] or 0, v["object_obb_iou"] or 0, |
| v["pl"] or 0, v["n_clip"] or 0)) |
| print(f"\nCSV: {csv_path}\nJSON: {out_root/'results_summary.json'}") |
| return payload |
|
|
|
|
| def main(): |
| pre = argparse.ArgumentParser(add_help=False) |
| pre.add_argument("--protocol", default=None, help="JSON file providing evaluator defaults") |
| pre_args, _ = pre.parse_known_args() |
| protocol_defaults = {} |
| if pre_args.protocol: |
| protocol_path = Path(pre_args.protocol).resolve() |
| protocol_defaults = json.loads(protocol_path.read_text(encoding="utf-8")) |
| if not isinstance(protocol_defaults, dict): |
| raise ValueError(f"protocol must be a JSON object: {protocol_path}") |
|
|
| ap = argparse.ArgumentParser(parents=[pre]) |
| ap.add_argument( |
| "--data_root", |
| required=True, |
| help="Dataset root containing gt/ and one directory per submitted model.", |
| ) |
| ap.add_argument("--models", required=True) |
| ap.add_argument("--gpus", default="2,3,5,7") |
| ap.add_argument("--workers_per_gpu", type=int, default=2) |
| ap.add_argument("--threads_per_worker", type=int, default=10, |
| help="cap CPU threads per worker (geometry stage is CPU-bound)") |
| ap.add_argument("--blender_bin", default="blender") |
| ap.add_argument("--clip_model_path", default="openai/clip-vit-base-patch32") |
| ap.add_argument("--clip_batch_size", type=int, default=32) |
| ap.add_argument("--alignment", default="bbox") |
| ap.add_argument( |
| "--ground_policy", |
| choices=["exclude", "include"], |
| default="exclude", |
| help="Whether bbox alignment and geometry IoU exclude detected ground planes.", |
| ) |
| ap.add_argument("--out_root", required=True) |
| ap.add_argument("--only_samples", default=None) |
| ap.add_argument( |
| "--track_manifest", |
| default=None, |
| help="Optional static/dynamic track manifest; sample ids are used as an evaluation filter.", |
| ) |
| ap.add_argument("--default_frame_mode", default="first_only") |
| ap.add_argument("--resolution_x", type=int, default=768) |
| ap.add_argument("--resolution_y", type=int, default=432) |
| ap.add_argument("--render_samples", type=int, default=32) |
| ap.add_argument( |
| "--render_engine", |
| choices=["BLENDER_EEVEE", "BLENDER_EEVEE_NEXT", "CYCLES"], |
| default="BLENDER_EEVEE", |
| ) |
| ap.add_argument("--limit", type=int, default=0, help="cap number of samples (debug)") |
| ap.add_argument("--retries", type=int, default=1) |
| ap.add_argument("--force", action="store_true", help="re-run even if final_report exists") |
| ap.add_argument("--aggregate_only", action="store_true") |
| ap.add_argument( |
| "--allow_partial", |
| action="store_true", |
| help="Allow missing models or failed samples. Off by default for comparable benchmark results.", |
| ) |
| known_destinations = {action.dest for action in ap._actions} |
| unknown_defaults = sorted(set(protocol_defaults) - known_destinations) |
| if unknown_defaults: |
| raise ValueError(f"unknown protocol keys: {', '.join(unknown_defaults)}") |
| ap.set_defaults(**protocol_defaults) |
| args = ap.parse_args() |
|
|
| data_root = Path(args.data_root).resolve() |
| models = [m.strip() for m in args.models.split(",") if m.strip()] |
| only = set(s.strip() for s in args.only_samples.split(",") if s.strip()) if args.only_samples else None |
| if args.track_manifest: |
| manifest_path = Path(args.track_manifest).resolve() |
| manifest_ids = load_track_manifest_sample_ids(manifest_path) |
| mode_by_sample = load_track_manifest_modes(manifest_path, args.default_frame_mode) |
| only = manifest_ids if only is None else only & manifest_ids |
| print(f"track_manifest={args.track_manifest} sample_ids={len(manifest_ids)} active_filter={len(only)}") |
| else: |
| mode_by_sample = {} |
| out_root = Path(args.out_root) |
| out_root.mkdir(parents=True, exist_ok=True) |
|
|
| samples = collect_samples( |
| data_root, |
| models, |
| only, |
| args.default_frame_mode, |
| mode_by_sample=mode_by_sample, |
| allow_missing_models=args.allow_partial, |
| ) |
| if args.limit: |
| samples = samples[:args.limit] |
| if not samples: |
| raise SystemExit("no evaluation samples found") |
| print(f"collected {len(samples)} samples; gpus={args.gpus} x {args.workers_per_gpu} workers") |
|
|
| if not args.aggregate_only: |
| wq: queue.Queue = queue.Queue() |
| for item in samples: |
| wq.put(item) |
| gpus = [g.strip() for g in args.gpus.split(",") if g.strip()] |
| results: list = [] |
| lock = threading.Lock() |
| threads = [] |
| for gpu in gpus: |
| for _ in range(args.workers_per_gpu): |
| t = threading.Thread(target=worker, args=(wq, gpu, args, results, lock)) |
| t.start() |
| threads.append(t) |
| for t in threads: |
| t.join() |
| ok = sum(1 for _, o, _ in results if o) |
| print(f"\n=== eval done: {ok}/{len(results)} ok ===") |
| if ok != len(results) and not args.allow_partial: |
| failed = [f"{sid}: {msg}" for sid, success, msg in results if not success] |
| raise SystemExit("evaluation failed:\n " + "\n ".join(failed)) |
|
|
| aggregate(out_root, samples, models, allow_partial=args.allow_partial) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
