Reorganize: scripts/eval/embed_figures.py

scripts/eval/embed_figures.py

@@ -0,0 +1,107 @@
+"""Compute CLIP embeddings for all extracted patent figures.
+
+Uses open_clip ViT-L/14 (best open-source CLIP) to embed each TIF.
+Saves embeddings as parquet with figure_id index for fast lookup.
+
+Usage:
+    python scripts/eval/embed_figures.py \
+        --enriched data/enriched/enriched_2022.parquet \
+        --images /tmp/patent_sample/2022 \
+        --out data/embeddings/embeddings_2022.parquet \
+        --batch 64
+"""
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+import open_clip
+import pandas as pd
+import torch
+from PIL import Image
+from tqdm import tqdm
+
+
+def find_image(images_dir: Path, image_filename: str) -> Path | None:
+    parts = image_filename.split("-D0")
+    if len(parts) < 2:
+        return None
+    p = images_dir / parts[0] / image_filename
+    return p if p.exists() else None
+
+
+def embed_batch(model, preprocess, paths: list[Path], device: str) -> np.ndarray:
+    imgs = []
+    for p in paths:
+        try:
+            img = Image.open(p).convert("RGB")
+            imgs.append(preprocess(img))
+        except Exception:
+            imgs.append(torch.zeros(3, 224, 224))
+    batch = torch.stack(imgs).to(device)
+    with torch.no_grad():
+        feats = model.encode_image(batch)
+        feats = feats / feats.norm(dim=-1, keepdim=True)
+    return feats.cpu().numpy()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--enriched", default="data/enriched/enriched_2022.parquet")
+    parser.add_argument("--images", default="/tmp/patent_sample/2022")
+    parser.add_argument("--out", default="data/embeddings/embeddings_2022.parquet")
+    parser.add_argument("--batch", type=int, default=64)
+    parser.add_argument("--model", default="ViT-L-14")
+    parser.add_argument("--pretrained", default="openai")
+    args = parser.parse_args()
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Device: {device}")
+
+    print(f"Loading {args.model} ({args.pretrained})...")
+    model, _, preprocess = open_clip.create_model_and_transforms(
+        args.model, pretrained=args.pretrained
+    )
+    model = model.to(device).eval()
+
+    df = pd.read_parquet(args.enriched)
+    images_dir = Path(args.images)
+
+    # Resolve image paths
+    df["_img_path"] = df["image_filename"].apply(
+        lambda fn: find_image(images_dir, fn)
+    )
+    found = df["_img_path"].notna().sum()
+    print(f"Images resolved: {found:,} / {len(df):,}")
+    df = df[df["_img_path"].notna()].reset_index(drop=True)
+
+    # Embed in batches
+    all_ids, all_vecs = [], []
+    batch_size = args.batch
+    paths = df["_img_path"].tolist()
+    fig_ids = df["figure_id"].tolist()
+
+    for i in tqdm(range(0, len(paths), batch_size), desc="Embedding"):
+        batch_paths = paths[i : i + batch_size]
+        batch_ids = fig_ids[i : i + batch_size]
+        vecs = embed_batch(model, preprocess, batch_paths, device)
+        all_ids.extend(batch_ids)
+        all_vecs.append(vecs)
+
+    all_vecs = np.vstack(all_vecs)
+    print(f"Embedding matrix: {all_vecs.shape}")
+
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    out_df = pd.DataFrame({"figure_id": all_ids})
+    # Store each embedding dimension as a column — efficient for FAISS loading
+    out_df["embedding"] = list(all_vecs)
+    out_df.to_parquet(args.out, index=False)
+    print(f"Saved → {args.out}")
+
+    # Quick sanity check
+    print(f"Sample figure: {all_ids[0]}")
+    print(f"Embedding norm: {np.linalg.norm(all_vecs[0]):.4f} (should be 1.0)")
+
+
+if __name__ == "__main__":
+    main()