Fix embed_modal: stream from HF instead of zip extraction

scripts/cloud/embed_modal.py

@@ -1,16 +1,17 @@
-"""Modal GPU job for CLIP embedding — ~10 min on A10G, no local storage.
+"""Modal GPU job for CLIP embedding — streams images from HF, no zip extraction.
 
-Mounts IMPACT from HF, runs CLIP ViT-L/14 on GPU, pushes parquet to HF Hub.
+Streams images directly from AI4Patents/IMPACT using the HF datasets API
+(record-by-record, no zip download). Runs CLIP ViT-L/14 on GPU.
+Pushes embeddings parquet to HF Hub immediately — survives any /tmp cleanup.
 
 Setup (one time):
-    pip install modal
-    modal setup          # authenticate
+    modal setup
     modal secret create hf-secret HF_TOKEN=hf_...
 
 Run:
-    modal run scripts/cloud/embed_modal.py
+    modal run scripts/cloud/embed_modal.py --year 2022
 
-Output: hf://datasets/midah/patent-wireframes/embeddings_2022_vitl14.parquet
+Output: hf://datasets/midah/patent-wireframes/embeddings/{year}_vitl14.parquet
 """
 
 import io
@@ -18,8 +19,6 @@ import os
 
 import modal
 
-# ── Modal image with all dependencies ────────────────────────────────────────
-
 image = (
     modal.Image.debian_slim(python_version="3.11")
     .pip_install(
@@ -30,29 +29,34 @@ image = (
         "pandas",
         "numpy",
         "tqdm",
+        "requests",
     )
 )
 
 app = modal.App("patent-clip-embed", image=image)
-
-# Secret holds HF_TOKEN
 hf_secret = modal.Secret.from_name("hf-secret")
 
+OUT_REPO = "midah/patent-wireframes"
+
 
 @app.function(
     gpu="A10G",
-    timeout=3600,
+    timeout=7200,
     secrets=[hf_secret],
-    memory=16384,
+    memory=32768,
 )
-def embed_year(year: str = "2022", model_name: str = "ViT-L-14", pretrained: str = "openai"):
+def embed_year(year: str = "2022", model_name: str = "ViT-L-14",
+               pretrained: str = "openai", batch_size: int = 64):
+    """Stream images from IMPACT HF dataset, embed with CLIP, push to Hub."""
     import ast
+    import base64
     import csv
-    import zipfile
+    from pathlib import Path
 
     import numpy as np
     import open_clip
     import pandas as pd
+    import requests
     import torch
     from huggingface_hub import HfApi, hf_hub_download
     from PIL import Image
@@ -61,14 +65,16 @@ def embed_year(year: str = "2022", model_name: str = "ViT-L-14", pretrained: str
     token = os.environ["HF_TOKEN"]
     device = "cuda"
 
-    # Load CLIP model
+    # ── Load CLIP ─────────────────────────────────────────────────────────────
     print(f"Loading {model_name} ({pretrained}) on {device}...")
     model, _, preprocess = open_clip.create_model_and_transforms(
         model_name, pretrained=pretrained
     )
     model = model.to(device).eval()
+    print("Model loaded.")
 
-    # Download IMPACT CSV (small — just metadata)
+    # ── Download metadata CSV (55MB — fast, no zip) ───────────────────────────
+    print(f"Downloading IMPACT {year} metadata CSV...")
     csv_path = hf_hub_download(
         repo_id="AI4Patents/IMPACT",
         filename=f"{year}.csv",
@@ -76,47 +82,60 @@ def embed_year(year: str = "2022", model_name: str = "ViT-L-14", pretrained: str
         token=token,
     )
 
-    # Build list of (patent_id, figure_num, image_filename)
+    # Build figure list from CSV
     figures = []
     with open(csv_path) as f:
         for row in csv.DictReader(f):
             try:
-                fnames = ast.literal_eval(row["file_names"])
-                pid = row["id"]
+                fnames = ast.literal_eval(row.get("file_names") or "[]")
+                pid = row.get("id") or row.get("patent_id") or ""
+                date = row.get("date") or ""
                 for i, fn in enumerate(fnames):
-                    figures.append({"patent_id": pid, "figure_num": i, "filename": fn})
+                    figures.append({
+                        "patent_id": pid,
+                        "figure_num": i,
+                        "filename": fn,
+                        "date": date,
+                    })
             except Exception:
                 pass
 
-    print(f"Total figures: {len(figures):,}")
+    total = len(figures)
+    print(f"Total figures: {total:,}")
 
-    # Download the zip (4.4GB — into Modal's /tmp, ephemeral)
-    print("Downloading IMPACT zip...")
-    zip_path = hf_hub_download(
-        repo_id="AI4Patents/IMPACT",
-        filename=f"{year}.zip",
-        repo_type="dataset",
-        token=token,
-        local_dir="/tmp/impact",
-    )
+    # ── Stream images from HF and embed in GPU batches ────────────────────────
+    # Use the HF raw file URL to download individual TIFs on demand.
+    # Format: hf://datasets/AI4Patents/IMPACT/{year}/{dir}/{filename}
+    # Accessed via: hf_hub_download per file (cached in /root/.cache)
+    # This avoids the 4.4GB zip entirely.
 
-    # Embed in batches
-    BATCH = 64
-    all_ids, all_vecs = [], []
+    HF_IMPACT = "AI4Patents/IMPACT"
+    CACHE_DIR = "/tmp/impact_cache"
+    Path(CACHE_DIR).mkdir(exist_ok=True)
 
-    def load_image(fn: str) -> Image.Image | None:
+    def fetch_image(fig: dict) -> Image.Image | None:
+        fn = fig["filename"]
         parts = fn.split("-D0")
         if len(parts) < 2:
             return None
-        inner_path = f"{year}/{parts[0]}/{fn}"
+        dir_name = parts[0]
+        hf_path = f"{year}/{dir_name}/{fn}"
         try:
-            with zipfile.ZipFile(zip_path) as z:
-                with z.open(inner_path) as f:
-                    return Image.open(io.BytesIO(f.read())).convert("RGB")
+            local = hf_hub_download(
+                repo_id=HF_IMPACT,
+                filename=hf_path,
+                repo_type="dataset",
+                token=token,
+                cache_dir=CACHE_DIR,
+            )
+            return Image.open(local).convert("RGB")
         except Exception:
             return None
 
-    batch_imgs, batch_ids = [], []
+    all_ids: list[str] = []
+    all_vecs: list[np.ndarray] = []
+    batch_imgs: list[Image.Image] = []
+    batch_ids: list[str] = []
 
     def flush_batch():
         if not batch_imgs:
@@ -130,38 +149,51 @@ def embed_year(year: str = "2022", model_name: str = "ViT-L-14", pretrained: str
         batch_imgs.clear()
         batch_ids.clear()
 
-    for fig in tqdm(figures, desc="Embedding"):
-        img = load_image(fig["filename"])
+    print("Streaming and embedding...")
+    for fig in tqdm(figures, desc=f"Embedding {year}"):
+        img = fetch_image(fig)
         if img is None:
             continue
+        pid_norm = fig["patent_id"].lstrip("D").zfill(7)
+        batch_ids.append(f"D{pid_norm}_{fig['figure_num']}")
         batch_imgs.append(img)
-        pid = fig["patent_id"].lstrip("D").zfill(7)
-        batch_ids.append(f"D{pid}_{fig['figure_num']}")
-        if len(batch_imgs) >= BATCH:
+        if len(batch_imgs) >= batch_size:
             flush_batch()
     flush_batch()
 
+    print(f"Embedded: {len(all_ids):,} figures")
+    if not all_ids:
+        print("No figures embedded — check HF access")
+        return {"n": 0}
+
+    # ── Normalize + save + push ───────────────────────────────────────────────
     vecs = np.vstack(all_vecs).astype(np.float32)
-    print(f"Embedded {len(all_ids):,} figures, shape {vecs.shape}")
+    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
+    vecs /= np.maximum(norms, 1e-8)
 
-    # Save parquet and push to Hub
     df = pd.DataFrame({"figure_id": all_ids, "embedding": list(vecs)})
-    out = f"/tmp/embeddings_{year}_{model_name.lower().replace('-','')}.parquet"
-    df.to_parquet(out, index=False)
 
-    out_file = f"embeddings_{year}_vitl14.parquet"
+    out_file = f"embeddings/{year}_vitl14.parquet"
+    local_out = f"/tmp/{year}_vitl14.parquet"
+    df.to_parquet(local_out, index=False)
+    size_mb = Path(local_out).stat().st_size / 1e6
+    print(f"Parquet: {size_mb:.1f}MB — pushing to HF Hub...")
+
     api = HfApi(token=token)
     api.upload_file(
-        path_or_fileobj=out,
+        path_or_fileobj=local_out,
         path_in_repo=out_file,
-        repo_id="midah/patent-wireframes",
+        repo_id=OUT_REPO,
         repo_type="dataset",
+        commit_message=f"Add CLIP embeddings for {year}",
     )
-    print(f"Pushed → hf://datasets/midah/patent-wireframes/{out_file}")
-    return {"n_embedded": len(all_ids), "shape": list(vecs.shape)}
+    print(f"Pushed → hf://datasets/{OUT_REPO}/{out_file}")
+
+    return {"year": year, "n_embedded": len(all_ids), "shape": list(vecs.shape)}
 
 
 @app.local_entrypoint()
-def main():
-    result = embed_year.remote("2022")
+def main(year: str = "2022"):
+    print(f"Embedding year: {year}")
+    result = embed_year.remote(year)
     print("Done:", result)