"""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()