Datasets:

midah
/

patent-wireframes

@@ -1,374 +0,0 @@
-"""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()