Add scripts/cloud/process_full_corpus.py

scripts/cloud/process_full_corpus.py

@@ -0,0 +1,342 @@
+"""Process the full 2007–2022 IMPACT corpus — one year at a time.
+
+For each year:
+  1. Download PatentsView text TSVs from S3 (~500MB-2GB/year)
+  2. Extract with 7-zip (handles deflate64 that Python's zipfile can't)
+  3. Join with IMPACT CSV (enriched parquet with text + viewpoints)
+  4. Embed images via HF Inference Endpoint (no local GPU needed)
+  5. Push enriched parquet + embeddings to HF Hub
+  6. Delete local files before processing next year
+
+Net local disk at any time: ~5-7GB (one year)
+Total cloud cost estimate: ~$1.20 for all 3.61M figures (GPU endpoint)
+
+Prerequisites:
+  - p7zip installed: brew install p7zip
+  - HF_TOKEN set in .env with write access to midah/patent-wireframes
+  - HF Inference Endpoint running (use create_hf_endpoint.py, or pass --endpoint-url)
+
+Usage:
+    # Process all years (creates/deletes endpoint per year):
+    python scripts/cloud/process_full_corpus.py --years 2007-2022
+
+    # Single year with existing endpoint:
+    python scripts/cloud/process_full_corpus.py --years 2022 \
+        --endpoint-url https://your-endpoint.huggingface.cloud
+
+    # Text enrichment only (no embedding):
+    python scripts/cloud/process_full_corpus.py --years 2022 --text-only
+"""
+
+import argparse
+import ast
+import csv
+import os
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+import pandas as pd
+import requests
+from dotenv import load_dotenv
+from huggingface_hub import HfApi, hf_hub_download
+from tqdm import tqdm
+
+load_dotenv(".env")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
+OUT_REPO = "midah/patent-wireframes"
+
+PATENTSVIEW_URLS = {
+    "drawing_desc":  "https://s3.amazonaws.com/data.patentsview.org/draw-description-text/g_draw_desc_text_{year}.tsv.zip",
+    "detail_desc":   "https://s3.amazonaws.com/data.patentsview.org/detail-description-text/g_detail_desc_text_{year}.tsv.zip",
+    "brf_sum":       "https://s3.amazonaws.com/data.patentsview.org/brief-summary-text/g_brf_sum_text_{year}.tsv.zip",
+    "claims":        "https://s3.amazonaws.com/data.patentsview.org/claims/g_claims_{year}.tsv.zip",
+    "patent_meta":   "https://s3.amazonaws.com/data.patentsview.org/download/g_patent.tsv.zip",
+}
+
+CHUNK = 8 * 1024 * 1024
+
+
+# ── Utilities ────────────────────────────────────────────────────────────────
+
+def download_file(url: str, dest: Path) -> Path:
+    if dest.exists() and dest.stat().st_size > 1024:
+        print(f"  Cached: {dest.name}")
+        return dest
+    print(f"  Downloading {dest.name}...")
+    r = requests.get(url, stream=True, timeout=120)
+    r.raise_for_status()
+    total = int(r.headers.get("content-length", 0))
+    with open(dest, "wb") as f, tqdm(total=total, unit="B", unit_scale=True) as pbar:
+        for chunk in r.iter_content(CHUNK):
+            f.write(chunk); pbar.update(len(chunk))
+    return dest
+
+
+def extract_7z(zip_path: Path, out_dir: Path) -> Path | None:
+    """Extract using p7zip (handles deflate64)."""
+    result = subprocess.run(
+        ["7za", "x", str(zip_path), f"-o{out_dir}", "-y"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        print(f"  7za error: {result.stderr[:100]}")
+        return None
+    tsv_files = list(out_dir.glob("*.tsv"))
+    return tsv_files[0] if tsv_files else None
+
+
+def agg_text(df: pd.DataFrame, id_col: str, text_col: str) -> pd.DataFrame:
+    if df.empty or text_col not in df.columns:
+        return pd.DataFrame(columns=[id_col, text_col])
+    return (
+        df.groupby(id_col)[text_col]
+        .apply(lambda x: "\n".join(x.dropna().astype(str)))
+        .reset_index()
+    )
+
+
+# ── Text enrichment ──────────────────────────────────────────────────────────
+
+def enrich_year(year: str, work_dir: Path) -> pd.DataFrame:
+    """Download IMPACT CSV + PatentsView text, join, return enriched DataFrame."""
+    api = HfApi(token=HF_TOKEN)
+
+    # IMPACT metadata CSV
+    csv_path = hf_hub_download(
+        repo_id="AI4Patents/IMPACT", filename=f"{year}.csv",
+        repo_type="dataset", token=HF_TOKEN, local_dir=str(work_dir),
+    )
+    impact = pd.read_csv(csv_path, low_memory=False)
+    print(f"  IMPACT {year}: {len(impact):,} patents")
+
+    # Explode to figure level
+    rows = []
+    for _, row in impact.iterrows():
+        try:
+            fnames = ast.literal_eval(str(row.get("file_names", "[]")))
+            fig_descs = ast.literal_eval(str(row.get("fig_desc", "[]")))
+        except Exception:
+            fnames, fig_descs = [], []
+        base = {k: v for k, v in row.items()
+                if k not in ("file_names", "fig_desc")}
+        if not fnames:
+            rows.append({**base, "figure_number": 0, "image_filename": ""})
+        else:
+            for i, fn in enumerate(fnames):
+                rows.append({**base, "figure_number": i, "image_filename": fn})
+    df = pd.DataFrame(rows)
+    df.rename(columns={"id": "patent_id", "title": "patent_title"}, inplace=True)
+    print(f"  Exploded: {len(df):,} figures")
+
+    # Download + extract PatentsView text tables
+    text_tables = {}
+    for tname, url_tpl in PATENTSVIEW_URLS.items():
+        if tname == "patent_meta":
+            url = url_tpl
+        else:
+            url = url_tpl.format(year=year)
+        zip_dest = work_dir / url.split("/")[-1]
+        try:
+            download_file(url, zip_dest)
+            tsv = extract_7z(zip_dest, work_dir / tname)
+            if tsv:
+                text_tables[tname] = pd.read_csv(tsv, sep="\t", dtype=str, low_memory=False)
+                print(f"  {tname}: {len(text_tables[tname]):,} rows")
+                zip_dest.unlink()  # free space immediately
+        except Exception as e:
+            print(f"  Skipping {tname}: {e}")
+
+    # Join text tables
+    for canonical, (tname, tcol) in {
+        "drawing_description": ("drawing_desc", "draw_desc_text"),
+        "detailed_description": ("detail_desc", "detail_desc_text"),
+        "brief_summary": ("brf_sum", "brf_sum_text"),
+        "claims": ("claims", "claims_text"),
+    }.items():
+        tdf = text_tables.get(tname, pd.DataFrame())
+        if not tdf.empty and tcol in tdf.columns:
+            tdf = tdf.rename(columns={"patent_id": "patent_id"})
+            agg = agg_text(tdf, "patent_id", tcol).rename(columns={tcol: canonical})
+            df = df.merge(agg, on="patent_id", how="left")
+        df[canonical] = df.get(canonical, pd.Series("")).fillna("")
+
+    # Patent metadata
+    meta = text_tables.get("patent_meta", pd.DataFrame())
+    if not meta.empty:
+        meta_cols = ["patent_id"] + [c for c in ["patent_date","patent_type"] if c in meta.columns]
+        df = df.merge(meta[meta_cols].drop_duplicates("patent_id"), on="patent_id", how="left")
+
+    df["year"] = int(year)
+    return df
+
+
+# ── Embedding via HF endpoint ────────────────────────────────────────────────
+
+def embed_year_via_endpoint(year: str, df: pd.DataFrame, endpoint_url: str,
+                             zip_path: str, work_dir: Path) -> pd.DataFrame:
+    """Embed all figures using the running HF Inference Endpoint."""
+    import base64
+    import io
+    import zipfile
+    import numpy as np
+    from PIL import Image
+
+    def encode_img(img_bytes):
+        img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+        w, h = img.size
+        scale = min(224 / max(w, h), 1.0)
+        if scale < 1.0:
+            img = img.resize((int(w*scale), int(h*scale)), Image.LANCZOS)
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=85)
+        return base64.standard_b64encode(buf.getvalue()).decode()
+
+    def post_batch(b64s):
+        for attempt in range(4):
+            try:
+                r = requests.post(endpoint_url, headers={**HF_HEADERS, "Content-Type":"application/json"},
+                                  json={"inputs": b64s}, timeout=60)
+                if r.status_code == 200:
+                    data = r.json()
+                    if isinstance(data, list) and data and isinstance(data[0], list):
+                        if isinstance(data[0][0], float):
+                            return data
+                        if isinstance(data[0][0], list):
+                            return [d[0] for d in data]
+            except Exception:
+                pass
+            time.sleep(2 ** attempt)
+        return None
+
+    all_ids, all_vecs = [], []
+    batch_imgs, batch_ids = [], []
+
+    def flush():
+        if not batch_imgs:
+            return
+        vecs = post_batch(batch_imgs)
+        if vecs:
+            all_ids.extend(batch_ids)
+            all_vecs.extend(vecs)
+        batch_imgs.clear(); batch_ids.clear()
+
+    with zipfile.ZipFile(zip_path) as zf:
+        for _, row in tqdm(df.iterrows(), total=len(df), desc=f"Embedding {year}"):
+            fn = str(row.get("image_filename",""))
+            parts = fn.split("-D0")
+            if len(parts) < 2:
+                continue
+            inner = f"{year}/{parts[0]}/{fn}"
+            try:
+                with zf.open(inner) as f:
+                    img_bytes = f.read()
+                batch_ids.append(f"{row['patent_id']}_{row['figure_number']}")
+                batch_imgs.append(encode_img(img_bytes))
+                if len(batch_imgs) >= 32:
+                    flush()
+            except Exception:
+                continue
+    flush()
+
+    print(f"  Embedded: {len(all_ids):,} figures")
+    if not all_ids:
+        return pd.DataFrame()
+
+    vecs = np.array(all_vecs, dtype=np.float32)
+    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
+    vecs /= np.maximum(norms, 1e-8)
+    return pd.DataFrame({"figure_id": all_ids, "embedding": list(vecs)})
+
+
+# ── Year processing ─��────────────────────────────────────────────────────────
+
+def process_year_full(year: str, endpoint_url: str | None, text_only: bool):
+    api = HfApi(token=HF_TOKEN)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        work = Path(tmpdir)
+        print(f"\n{'='*50}")
+        print(f"Processing year {year}")
+        print(f"{'='*50}")
+
+        # Text enrichment
+        df = enrich_year(year, work)
+
+        # Save enriched parquet
+        out_parquet = work / f"enriched_{year}.parquet"
+        df.to_parquet(out_parquet, index=False)
+        size_mb = out_parquet.stat().st_size / 1e6
+        print(f"  Enriched parquet: {size_mb:.0f}MB, {len(df):,} rows")
+
+        api.upload_file(
+            path_or_fileobj=str(out_parquet),
+            path_in_repo=f"data/enriched_{year}.parquet",
+            repo_id=OUT_REPO, repo_type="dataset",
+            commit_message=f"Add enriched parquet for {year}",
+        )
+        print(f"  Pushed enriched_{year}.parquet → HF")
+
+        if text_only or not endpoint_url:
+            print("  Skipping embedding (--text-only or no endpoint URL)")
+            return
+
+        # Download images zip
+        print(f"  Downloading IMPACT {year} images (~4.4GB)...")
+        zip_path = hf_hub_download(
+            repo_id="AI4Patents/IMPACT", filename=f"{year}.zip",
+            repo_type="dataset", token=HF_TOKEN, local_dir=tmpdir,
+        )
+
+        # Embed
+        emb_df = embed_year_via_endpoint(year, df, endpoint_url, zip_path, work)
+        if emb_df.empty:
+            print("  No embeddings produced")
+            return
+
+        out_emb = work / f"embeddings_{year}_vitl14.parquet"
+        emb_df.to_parquet(out_emb, index=False)
+        api.upload_file(
+            path_or_fileobj=str(out_emb),
+            path_in_repo=f"embeddings/embeddings_{year}_vitl14.parquet",
+            repo_id=OUT_REPO, repo_type="dataset",
+            commit_message=f"Add CLIP embeddings for {year}",
+        )
+        print(f"  Pushed embeddings_{year}_vitl14.parquet → HF")
+        print(f"  Year {year} complete.")
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--years",        default="2022",
+                        help="Year or range: '2022', '2018-2022', '2007-2022'")
+    parser.add_argument("--endpoint-url", default=None,
+                        help="Running HF Inference Endpoint URL (skips creation)")
+    parser.add_argument("--text-only",    action="store_true",
+                        help="Only do text enrichment, skip embedding")
+    parser.add_argument("--out-repo",     default=OUT_REPO)
+    args = parser.parse_args()
+
+    # Parse year range
+    if "-" in args.years and args.years.count("-") == 1:
+        start, end = args.years.split("-")
+        years = [str(y) for y in range(int(start), int(end)+1)]
+    else:
+        years = [args.years]
+
+    print(f"Processing years: {years}")
+    print(f"Text only: {args.text_only}")
+    print(f"Endpoint: {args.endpoint_url or '(none — text only)'}")
+
+    for year in reversed(years):  # newest first
+        process_year_full(year, args.endpoint_url, args.text_only)
+
+    print("\nAll years complete.")
+
+
+if __name__ == "__main__":
+    main()