""" Batch CLIP scoring for all benchmark results. Computes CLIP similarity between generated HTML screenshots and reference images. Usage: conda activate uipress-qwen CUDA_VISIBLE_DEVICES=X PYTHONPATH=. python scripts/step_clip_batch.py """ import os os.environ["HF_ENDPOINT"] = os.environ.get("HF_ENDPOINT", "https://hf-mirror.com") os.environ["HF_HOME"] = os.environ.get("HF_HOME", "/root/rivermind-data/huggingface") import json import sys import tempfile from pathlib import Path import torch from PIL import Image from tqdm import tqdm PROJECT_ROOT = Path(__file__).parent.parent class CLIPScorer: def __init__(self, device="cuda"): import open_clip self.device = device self.model, _, self.preprocess = open_clip.create_model_and_transforms( "ViT-B-32", pretrained="openai" ) self.model = self.model.to(device).eval() @torch.no_grad() def score(self, img1, img2): t1 = self.preprocess(img1).unsqueeze(0).to(self.device) t2 = self.preprocess(img2).unsqueeze(0).to(self.device) f1 = self.model.encode_image(t1) f2 = self.model.encode_image(t2) f1 = f1 / f1.norm(dim=-1, keepdim=True) f2 = f2 / f2.norm(dim=-1, keepdim=True) return float((f1 * f2).sum()) def render_html(html_path, output_path, width=1280, height=1024): try: from playwright.sync_api import sync_playwright abs_path = os.path.abspath(html_path) with sync_playwright() as p: browser = p.chromium.launch(headless=True) page = browser.new_page(viewport={"width": width, "height": height}) page.goto(f"file://{abs_path}", wait_until="networkidle", timeout=30000) page.screenshot(path=output_path, full_page=False) browser.close() return True except Exception as e: try: from selenium import webdriver from selenium.webdriver.chrome.options import Options opts = Options() opts.add_argument("--headless") opts.add_argument("--no-sandbox") opts.add_argument(f"--window-size={width},{height}") driver = webdriver.Chrome(options=opts) driver.get(f"file://{os.path.abspath(html_path)}") import time; time.sleep(2) driver.save_screenshot(output_path) driver.quit() return True except: return False def eval_method(method_dir, ref_dir, scorer, tmp_dir): html_dir = Path(method_dir) / "html_predictions" if not html_dir.exists(): return None html_files = sorted(html_dir.glob("*.html")) if not html_files: return None scores = {} for hf in tqdm(html_files, desc=f"CLIP {html_dir.parent.name}"): sid = hf.stem ref_img_path = Path(ref_dir) / f"{sid}.png" if not ref_img_path.exists(): continue ref_img = Image.open(ref_img_path).convert("RGB") pred_img_path = os.path.join(tmp_dir, f"{sid}.png") ok = render_html(str(hf), pred_img_path) if ok and os.path.exists(pred_img_path): pred_img = Image.open(pred_img_path).convert("RGB") clip = scorer.score(ref_img, pred_img) else: clip = 0.0 scores[sid] = clip if not scores: return None vals = list(scores.values()) return { "n": len(vals), "avg_clip": round(sum(vals) / len(vals), 4), "min_clip": round(min(vals), 4), "max_clip": round(max(vals), 4), "per_sample": {k: round(v, 4) for k, v in scores.items()}, } def compute_clip_for_method_dir( method_dir: str | Path, ref_dir: str | Path, device: str = "cuda", ) -> dict | None: """Run CLIP on one benchmark folder (contains html_predictions/). Writes clip_scores.json.""" method_dir = Path(method_dir) ref_dir = Path(ref_dir) scorer = CLIPScorer(device=device) with tempfile.TemporaryDirectory() as tmp: result = eval_method(method_dir, ref_dir, scorer, tmp) if result and method_dir.is_dir(): clip_file = method_dir / "clip_scores.json" with open(clip_file, "w") as f: json.dump(result, f, indent=2) return result def main(): import argparse parser = argparse.ArgumentParser() parser.add_argument("--benchmark_dir", default=str(PROJECT_ROOT / "results" / "benchmark")) parser.add_argument("--ref_dir", default=str(PROJECT_ROOT / "data" / "ref_screenshots")) parser.add_argument("--methods", nargs="*", default=None) parser.add_argument( "--method_dir", default=None, help="If set, only score this folder (must contain html_predictions/) and exit.", ) parser.add_argument( "--clip_device", default="cuda", choices=["cuda", "cpu"], help="CLIP ViT device; use cpu if all GPUs are full.", ) args = parser.parse_args() if args.method_dir: r = compute_clip_for_method_dir( args.method_dir, args.ref_dir, device=args.clip_device, ) if r: print(json.dumps(r, indent=2)) else: print("No scores (missing html_predictions or no matches).", file=sys.stderr) sys.exit(1) return bench_dir = Path(args.benchmark_dir) ref_dir = Path(args.ref_dir) if not ref_dir.exists(): print(f"Reference dir not found: {ref_dir}") sys.exit(1) scorer = CLIPScorer() all_clip = {} methods = args.methods or sorted( d.name for d in bench_dir.iterdir() if d.is_dir() and (d / "html_predictions").exists() ) with tempfile.TemporaryDirectory() as tmp: for method in methods: method_dir = bench_dir / method if not method_dir.exists(): continue print(f"\n=== {method} ===") result = eval_method(method_dir, ref_dir, scorer, tmp) if result: all_clip[method] = result print(f" CLIP: {result['avg_clip']:.4f} (n={result['n']})") clip_file = method_dir / "clip_scores.json" with open(clip_file, "w") as f: json.dump(result, f, indent=2) agg_file = bench_dir / "all_clip_scores.json" summary = {k: {kk: vv for kk, vv in v.items() if kk != "per_sample"} for k, v in all_clip.items()} with open(agg_file, "w") as f: json.dump(summary, f, indent=2) print(f"\n{'='*60}") print(f"{'Method':<20} {'CLIP':>8} {'N':>5}") print("-" * 40) for k in sorted(summary, key=lambda x: summary[x]["avg_clip"], reverse=True): v = summary[k] print(f"{k:<20} {v['avg_clip']:>8.4f} {v['n']:>5}") print(f"{'='*60}") print(f"Saved to: {agg_file}") if __name__ == "__main__": main()