Reorganize: scripts/eval/build_sample.py

scripts/eval/build_sample.py

@@ -0,0 +1,374 @@
+"""Build a stratified evaluation sample with full observables per figure.
+
+Sampling strategy:
+  - Select DOMAIN_COUNT Locarno chapters (by patent count)
+  - Within each chapter, sample N_PER_DOMAIN patents stratified by text richness
+  - Within each patent, include all figures
+  - Compute all observables: text features, structural features, image complexity
+
+Produces: data/sample/eval_sample.parquet  (figures)
+          data/sample/eval_sample_patents.parquet  (per-patent aggregates)
+
+Usage:
+    python scripts/eval/build_sample.py \
+        --enriched data/enriched/enriched_2022.parquet \
+        --images /tmp/patent_sample/2022 \
+        --out data/sample \
+        --domains 8 \
+        --per-domain 100
+"""
+
+import argparse
+import re
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+from tqdm import tqdm
+
+
+# ── Locarno chapter labels ────────────────────────────────────────────────────
+
+CHAPTER_LABELS = {
+    'D14': 'Screens/electronics',
+    'D24': 'Medical',
+    'D12': 'Construction',
+    'D23': 'Fluid/sanitation',
+    'D21': 'Games/sports',
+    'D13': 'Transport',
+    'D26': 'Lighting',
+    'D29': 'Fire/accident prevention',
+    'D32': 'Graphic symbols/logos',
+    'D15': 'Machines',
+    'D10': 'Clocks/watches',
+    'D28': 'Pharma/cosmetics',
+    'D11': 'Ornamental articles',
+    'D27': 'Tobacco/recreation',
+    'D8':  'Tools/hardware',
+    'D9':  'Packaging',
+    'D16': 'Photo/optical',
+}
+
+
+# ── viewpoint parsing ─────────────────────────────────────────────────────────
+
+VP_BUCKETS = [
+    ('perspective',   lambda v: 'perspective' in v),
+    ('front_elev',    lambda v: 'front elev' in v or v in ('front elevation','front plan','front view')),
+    ('rear_elev',     lambda v: 'rear elev' in v or 'rear elevation' in v),
+    ('side_elev',     lambda v: 'side elev' in v or 'side elevation' in v),
+    ('top_plan',      lambda v: 'top plan' in v or v == 'top view'),
+    ('bottom_plan',   lambda v: 'bottom plan' in v or 'bottom' in v),
+    ('cross_section', lambda v: 'cross' in v or 'section' in v),
+    ('enlarged',      lambda v: 'enlarg' in v or 'detail' in v),
+    ('exploded',      lambda v: 'explod' in v),
+    ('reference',     lambda v: 'reference' in v),
+    ('unknown',       lambda v: True),
+]
+
+DIFFICULTY = {
+    'perspective': 'baseline',
+    'front_elev':  'easy',
+    'rear_elev':   'easy',
+    'side_elev':   'easy',
+    'top_plan':    'medium',
+    'bottom_plan': 'medium',
+    'enlarged':    'hard',
+    'cross_section': 'very_hard',
+    'exploded':    'hard',
+    'reference':   'baseline',
+    'unknown':     'unknown',
+}
+
+
+def parse_vp(desc: str, fig_num: int) -> str:
+    pat = re.compile(
+        rf"FIG\.\s*{fig_num + 1}\s+is\s+(?:a\s+|an\s+)?(.{{5,80}}?)\s*(?:view|thereof|;|\n|$)",
+        re.IGNORECASE,
+    )
+    m = pat.search(desc or "")
+    return m.group(1).strip().lower() if m else ""
+
+
+def bucket_vp(vp: str) -> str:
+    for name, fn in VP_BUCKETS:
+        if fn(vp):
+            return name
+    return "unknown"
+
+
+# ── image observables ─────────────────────────────────────────────────────────
+
+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 image_observables(img_path: Path) -> dict:
+    """Compute pixel-level features from a bilevel patent TIF."""
+    try:
+        img = Image.open(img_path)
+        arr = np.array(img)  # mode 1: True=white, False=black
+        h, w = arr.shape
+        total = h * w
+
+        ink_frac = (~arr).sum() / total
+
+        # Edge transitions (white→black per row, sampled)
+        transitions = int(sum(
+            np.sum(row[1:] < row[:-1])
+            for row in arr[::4]  # sample every 4th row
+        ))
+
+        # Perceptual hash proxy: 8×8 mean block comparison
+        from PIL import Image as PILImage
+        small = img.resize((32, 32), PILImage.LANCZOS).convert("L")
+        small_arr = np.array(small)
+        phash_var = float(small_arr.var())
+
+        return {
+            "ink_frac": float(ink_frac),
+            "edge_transitions": transitions,
+            "img_width": w,
+            "img_height": h,
+            "img_aspect": float(w / h) if h > 0 else 1.0,
+            "phash_var": phash_var,      # higher = more detail/complexity
+        }
+    except Exception:
+        return {
+            "ink_frac": None,
+            "edge_transitions": None,
+            "img_width": None,
+            "img_height": None,
+            "img_aspect": None,
+            "phash_var": None,
+        }
+
+
+# ── text observables ──────────────────────────────────────────────────────────
+
+def text_observables(row: pd.Series) -> dict:
+    draw = str(row.get("drawing_description") or "")
+    detail = str(row.get("detailed_description") or "")
+    claims = str(row.get("claims") or "")
+    summary = str(row.get("brief_summary") or "")
+    caption = str(row.get("caption") or "")
+
+    # Count FIG. references in draw_desc
+    n_fig_refs = len(re.findall(r"FIG\.\s*\d+", draw, re.IGNORECASE))
+
+    return {
+        "draw_desc_chars": len(draw),
+        "draw_desc_words": len(draw.split()),
+        "draw_desc_fig_refs": n_fig_refs,
+        "detail_desc_chars": len(detail),
+        "claims_chars": len(claims),
+        "summary_chars": len(summary),
+        "caption_chars": len(caption),
+        # Text richness quartile (filled in at patent level)
+    }
+
+
+# ── main ──────────────────────────────────────────────────────────────────────
+
+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/sample")
+    parser.add_argument("--domains",    type=int, default=8,
+                        help="Number of top Locarno chapters to include")
+    parser.add_argument("--per-domain", type=int, default=100,
+                        help="Max patents per domain")
+    parser.add_argument("--seed",       type=int, default=42)
+    args = parser.parse_args()
+
+    rng = np.random.default_rng(args.seed)
+    images_dir = Path(args.images)
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    print("Loading enriched data...")
+    df = pd.read_parquet(args.enriched)
+
+    # Parse chapter and viewpoint
+    df["locarno_chapter"] = (
+        df["class"].astype(str)
+        .str.extract(r"^(D\s*\d{1,2})", expand=False)
+        .str.replace(" ", "", regex=False)
+        .fillna("other")
+    )
+    df["vp_raw"] = df.apply(
+        lambda r: parse_vp(r.get("drawing_description", ""), r["figure_number"]),
+        axis=1,
+    )
+    df["vp_bucket"] = df["vp_raw"].apply(bucket_vp)
+    df["difficulty"] = df["vp_bucket"].map(DIFFICULTY)
+
+    # Text features at figure level
+    df["draw_desc_chars"] = df["drawing_description"].fillna("").str.len()
+    df["draw_desc_words"] = df["drawing_description"].fillna("").str.split().str.len()
+
+    # Image path
+    df["img_path"] = df["image_filename"].apply(lambda fn: find_image(images_dir, fn))
+
+    # Per-patent aggregates for richness quartile
+    patent_agg = df.groupby("patent_id").agg(
+        draw_len=("draw_desc_chars", "first"),
+        n_figs=("figure_id", "count"),
+        n_vp_types=("vp_bucket", "nunique"),
+        has_perspective=("vp_bucket", lambda x: "perspective" in x.values),
+        has_front=("vp_bucket", lambda x: "front_elev" in x.values),
+        has_cross=("vp_bucket", lambda x: "cross_section" in x.values),
+        parse_rate=("vp_bucket", lambda x: (x != "unknown").mean()),
+        chapter=("locarno_chapter", "first"),
+    ).reset_index()
+
+    patent_agg["text_richness_q"] = pd.qcut(
+        patent_agg["draw_len"], 4,
+        labels=["sparse", "moderate", "rich", "very_rich"]
+    ).astype(str)
+
+    # Select top domains
+    top_chapters = (
+        patent_agg[patent_agg["chapter"] != "other"]
+        .groupby("chapter")["patent_id"].count()
+        .sort_values(ascending=False)
+        .head(args.domains)
+        .index.tolist()
+    )
+    print(f"\nSelected domains: {top_chapters}")
+
+    # Stratified sample: within each domain, stratify by text richness
+    sampled_pids = []
+    for chapter in top_chapters:
+        chap_patents = patent_agg[patent_agg["chapter"] == chapter]
+        n = min(args.per_domain, len(chap_patents))
+        # Stratified by text richness (equal from each quartile if possible)
+        per_q = n // 4
+        chunk = []
+        for q in ["sparse", "moderate", "rich", "very_rich"]:
+            pool = chap_patents[chap_patents["text_richness_q"] == q]["patent_id"].tolist()
+            rng.shuffle(pool)
+            chunk.extend(pool[: per_q])
+        # Top up to n from the full pool
+        remaining = set(chap_patents["patent_id"]) - set(chunk)
+        remaining = list(remaining)
+        rng.shuffle(remaining)
+        chunk.extend(remaining[: n - len(chunk)])
+        sampled_pids.extend(chunk[:n])
+        label = CHAPTER_LABELS.get(chapter, chapter)
+        print(f"  {chapter} ({label}): {len(chunk[:n])} patents sampled")
+
+    print(f"\nTotal patents sampled: {len(sampled_pids)}")
+
+    # Filter to sampled patents
+    sample_df = df[df["patent_id"].isin(set(sampled_pids))].copy()
+    # Merge patent-level features
+    sample_df = sample_df.merge(
+        patent_agg[["patent_id", "text_richness_q", "n_vp_types",
+                     "has_perspective", "has_front", "has_cross", "parse_rate"]],
+        on="patent_id", how="left"
+    )
+    sample_df["domain_label"] = sample_df["locarno_chapter"].map(CHAPTER_LABELS).fillna(sample_df["locarno_chapter"])
+
+    print(f"Total figures in sample: {len(sample_df):,}")
+    print(f"Images available: {sample_df['img_path'].notna().sum():,}")
+
+    # Compute image observables on all available images
+    print("\nComputing image observables...")
+    img_obs_list = []
+    for _, row in tqdm(sample_df.iterrows(), total=len(sample_df)):
+        p = row["img_path"]
+        obs = image_observables(p) if p is not None else {}
+        obs["figure_id"] = row["figure_id"]
+        img_obs_list.append(obs)
+
+    img_obs_df = pd.DataFrame(img_obs_list)
+    sample_df = sample_df.merge(img_obs_df, on="figure_id", how="left")
+
+    # Summary
+    print("\n=== SAMPLE SUMMARY ===")
+    print(f"{'Domain':<6} {'Label':<22} {'Patents':>8} {'Figs':>8}")
+    for chap in top_chapters:
+        g = sample_df[sample_df["locarno_chapter"] == chap]
+        label = CHAPTER_LABELS.get(chap, chap)
+        print(f"  {chap:<6} {label:<22} {g['patent_id'].nunique():>8} {len(g):>8}")
+
+    print()
+    print("=== VIEWPOINT DISTRIBUTION IN SAMPLE ===")
+    vp_dist = sample_df["vp_bucket"].value_counts()
+    for vp, n in vp_dist.items():
+        print(f"  {vp:<16} {n:>6,}  ({n/len(sample_df):.1%})")
+
+    print()
+    print("=== TEXT RICHNESS IN SAMPLE ===")
+    for q, g in sample_df.groupby("text_richness_q", observed=True):
+        print(f"  {q:<12} {g['patent_id'].nunique():>5} patents  "
+              f"draw_len median: {g['draw_desc_chars'].median():.0f} chars")
+
+    # Save
+    cols_to_save = [
+        "figure_id", "patent_id", "figure_number", "n_figures_in_patent",
+        "sibling_figure_ids", "patent_title", "caption",
+        "drawing_description", "detailed_description", "brief_summary", "claims",
+        "vp_raw", "vp_bucket", "difficulty",
+        "locarno_chapter", "domain_label", "text_richness_q",
+        "draw_desc_chars", "draw_desc_words",
+        "detail_desc_chars" if "detail_desc_chars" in sample_df.columns else None,
+        "claims_chars" if "claims_chars" in sample_df.columns else None,
+        "n_vp_types", "has_perspective", "has_front", "has_cross", "parse_rate",
+        "ink_frac", "edge_transitions", "img_width", "img_height",
+        "img_aspect", "phash_var",
+        "image_filename", "year",
+    ]
+    cols_to_save = [c for c in cols_to_save if c and c in sample_df.columns]
+    sample_df[cols_to_save].to_parquet(out_dir / "eval_sample.parquet", index=False)
+
+    # Per-patent summary
+    patent_summary = sample_df.groupby("patent_id").agg(
+        n_figs=("figure_id", "count"),
+        locarno_chapter=("locarno_chapter", "first"),
+        domain_label=("domain_label", "first"),
+        text_richness_q=("text_richness_q", "first"),
+        draw_desc_chars=("draw_desc_chars", "first"),
+        n_vp_types=("n_vp_types", "first"),
+        has_perspective=("has_perspective", "first"),
+        has_front=("has_front", "first"),
+        has_cross=("has_cross", "first"),
+        parse_rate=("parse_rate", "first"),
+        median_ink_frac=("ink_frac", "median"),
+        median_edge_transitions=("edge_transitions", "median"),
+        median_phash_var=("phash_var", "median"),
+        patent_title=("patent_title", "first"),
+    ).reset_index()
+    patent_summary.to_parquet(out_dir / "eval_sample_patents.parquet", index=False)
+
+    print(f"\nSaved:")
+    print(f"  {out_dir}/eval_sample.parquet         ({len(sample_df):,} figures)")
+    print(f"  {out_dir}/eval_sample_patents.parquet ({len(patent_summary):,} patents)")
+    print()
+    print("=== OBSERVABLES CAPTURED ===")
+    obs_fields = {
+        "TEXT (draw_desc)": ["draw_desc_chars", "draw_desc_words", "text_richness_q"],
+        "TEXT (missing — need re-download)": ["detail_desc_chars", "claims_chars", "summary_chars"],
+        "STRUCTURAL": ["n_figures_in_patent", "n_vp_types", "has_perspective", "has_front", "has_cross", "parse_rate"],
+        "IMAGE": ["ink_frac", "edge_transitions", "img_aspect", "phash_var"],
+        "METADATA": ["locarno_chapter", "domain_label", "year"],
+    }
+    for group, fields in obs_fields.items():
+        available = [f for f in fields if f in sample_df.columns and sample_df[f].notna().any()]
+        missing = [f for f in fields if f not in available]
+        print(f"  {group}:")
+        if available:
+            print(f"    ✓ {', '.join(available)}")
+        if missing:
+            print(f"    ✗ {', '.join(missing)} (not in current data)")
+
+
+if __name__ == "__main__":
+    main()