Datasets:

midah
/

patent-wireframes

@@ -1,271 +0,0 @@
-"""Figure completion retrieval benchmark.
-Leave-one-out: for each patent, mask one view (by default the top plan view,
-or the hardest available). Given embeddings of N-1 sibling views as context,
-retrieve the correct masked view from a pool of 100 candidates.
-Baselines:
-  random     — chance (1%)
-  single     — embed only the perspective view, retrieve
-  multi      — average CLIP embeddings of all N-1 context views, retrieve
-  vlm        — (future) use VLM to describe missing view, embed description
-Usage:
-    python scripts/eval/retrieval_eval.py \
-        --embeddings data/embeddings/embeddings_2022_vitl14.parquet \
-        --enriched   data/enriched/enriched_2022.parquet \
-        --n          500 \
-        --pool-size  100 \
-        --out        results/retrieval_eval.json
-"""
-import argparse
-import json
-import random
-import re
-from collections import defaultdict
-from pathlib import Path
-import faiss
-import numpy as np
-import pandas as pd
-from tqdm import tqdm
-# ── viewpoint helpers ─────────────────────────────────────────────────────────
-def parse_viewpoint(drawing_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(drawing_desc or "")
-    return m.group(1).strip().lower() if m else ""
-TARGET_PRIORITY = [
-    # (label_fragment, difficulty)
-    ("cross-sectional", "very_hard"),
-    ("cross section",   "very_hard"),
-    ("enlarged",        "hard"),
-    ("detail",          "hard"),
-    ("top plan",        "hard"),
-    ("bottom plan",     "medium"),
-    ("rear elevation",  "medium"),
-    ("rear elev",       "medium"),
-    ("side elev",       "easy"),
-    ("front elev",      "easy"),
-    ("perspective",     "baseline"),
-]
-def pick_target_view(viewpoints: list[str]) -> tuple[int, str]:
-    """Pick the highest-priority masking target. Returns (index, difficulty)."""
-    for frag, difficulty in TARGET_PRIORITY:
-        for i, vp in enumerate(viewpoints):
-            if frag in vp:
-                return i, difficulty
-    # Fallback: pick any non-first view
-    return 1 if len(viewpoints) > 1 else 0, "unknown"
-# ── retrieval ─────────────────────────────────────────────────────────────────
-def build_faiss_index(vectors: np.ndarray) -> faiss.IndexFlatIP:
-    """Build an inner-product FAISS index (cosine sim on L2-normed vectors)."""
-    dim = vectors.shape[1]
-    index = faiss.IndexFlatIP(dim)
-    index.add(vectors.astype(np.float32))
-    return index
-def retrieve(
-    query_vec: np.ndarray,        # (dim,)
-    candidate_indices: list[int], # indices into the full embedding matrix
-    all_vectors: np.ndarray,
-    correct_idx: int,             # index into candidate_indices
-) -> dict:
-    """Score retrieval: rank correct candidate among candidates by cosine sim."""
-    cand_vecs = all_vectors[candidate_indices].astype(np.float32)
-    q = query_vec.astype(np.float32).reshape(1, -1)
-    sims = (cand_vecs @ q.T).squeeze()
-    ranks = np.argsort(-sims)  # descending
-    rank_of_correct = int(np.where(ranks == correct_idx)[0][0]) + 1  # 1-indexed
-    return {
-        "rank": rank_of_correct,
-        "r1":   int(rank_of_correct <= 1),
-        "r5":   int(rank_of_correct <= 5),
-        "r10":  int(rank_of_correct <= 10),
-        "sim_correct": float(sims[correct_idx]),
-        "sim_top1":    float(sims[ranks[0]]),
-    }
-# ── main eval ─────────────────────────────────────────────────────────────────
-def run_eval(
-    embeddings_path: str,
-    enriched_path:   str,
-    n: int,
-    pool_size: int,
-    out_path: str,
-    seed: int = 42,
-):
-    rng = random.Random(seed)
-    print("Loading embeddings...")
-    emb_df = pd.read_parquet(embeddings_path)
-    fig_id_to_idx = {fid: i for i, fid in enumerate(emb_df["figure_id"])}
-    all_vecs = np.vstack(emb_df["embedding"].tolist()).astype(np.float32)
-    # Ensure unit norm for cosine sim
-    norms = np.linalg.norm(all_vecs, axis=1, keepdims=True)
-    all_vecs = all_vecs / np.maximum(norms, 1e-8)
-    print(f"Embeddings: {all_vecs.shape}")
-    print("Loading enriched metadata...")
-    df = pd.read_parquet(enriched_path)
-    df["viewpoint_parsed"] = df.apply(
-        lambda r: parse_viewpoint(r.get("drawing_description", ""), r["figure_number"]),
-        axis=1,
-    )
-    # Keep only figures with embeddings
-    df = df[df["figure_id"].isin(fig_id_to_idx)].copy()
-    df["_vec_idx"] = df["figure_id"].map(fig_id_to_idx)
-    # Group by patent
-    patent_groups = {
-        pid: g.sort_values("figure_number")
-        for pid, g in df.groupby("patent_id")
-        if len(g) >= 3
-    }
-    # Build Locarno-class → figure_id list for distractor sampling
-    class_to_fids = defaultdict(list)
-    for _, row in df.iterrows():
-        cls = row.get("class") or row.get("locarno_class") or "unknown"
-        class_to_fids[str(cls)].append(row["figure_id"])
-    # Sample eligible patents
-    all_pids = list(patent_groups.keys())
-    rng.shuffle(all_pids)
-    eval_pids = all_pids[:n]
-    print(f"Evaluating {len(eval_pids)} patents (pool_size={pool_size})")
-    by_difficulty = defaultdict(lambda: {"r1": 0, "r5": 0, "r10": 0, "n": 0})
-    results = []
-    for pid in tqdm(eval_pids):
-        group = patent_groups[pid]
-        fids = group["figure_id"].tolist()
-        vps  = group["viewpoint_parsed"].tolist()
-        vec_idxs = group["_vec_idx"].tolist()
-        cls = str(group["class"].iloc[0] if "class" in group.columns else "unknown")
-        # Pick target view to mask
-        target_pos, difficulty = pick_target_view(vps)
-        target_fid = fids[target_pos]
-        target_vec_idx = vec_idxs[target_pos]
-        context_idxs = [vi for i, vi in enumerate(vec_idxs) if i != target_pos]
-        if not context_idxs:
-            continue
-        # Build query: average of context embeddings
-        query_vec = all_vecs[context_idxs].mean(axis=0)
-        query_vec /= max(np.linalg.norm(query_vec), 1e-8)
-        # Build candidate pool: target + (pool_size - 1) distractors from same class
-        distractors_pool = [
-            f for f in class_to_fids.get(cls, [])
-            if f not in set(fids) and f in fig_id_to_idx
-        ]
-        rng.shuffle(distractors_pool)
-        distractors = distractors_pool[: pool_size - 1]
-        if len(distractors) < pool_size - 1:
-            # Fill from any other patent
-            other_fids = [
-                f for f in df["figure_id"].tolist()
-                if f not in set(fids) and f not in set(distractors) and f in fig_id_to_idx
-            ]
-            rng.shuffle(other_fids)
-            distractors += other_fids[: pool_size - 1 - len(distractors)]
-        if len(distractors) < 3:
-            continue
-        candidates = distractors[: pool_size - 1]
-        # Insert correct answer at random position
-        insert_pos = rng.randint(0, len(candidates))
-        candidates.insert(insert_pos, target_fid)
-        candidate_vec_idxs = [fig_id_to_idx[f] for f in candidates]
-        # Multi-view retrieval
-        score = retrieve(query_vec, candidate_vec_idxs, all_vecs, insert_pos)
-        # Single-view retrieval (perspective only, if available)
-        persp_pos = next((i for i, v in enumerate(vps) if "perspective" in v and i != target_pos), None)
-        if persp_pos is not None:
-            single_score = retrieve(all_vecs[vec_idxs[persp_pos]], candidate_vec_idxs, all_vecs, insert_pos)
-        else:
-            single_score = score  # fallback
-        for bucket in [difficulty, "all"]:
-            by_difficulty[bucket]["r1"]  += score["r1"]
-            by_difficulty[bucket]["r5"]  += score["r5"]
-            by_difficulty[bucket]["r10"] += score["r10"]
-            by_difficulty[bucket]["n"]   += 1
-        results.append({
-            "patent_id":      pid,
-            "target_view":    vps[target_pos],
-            "difficulty":     difficulty,
-            "pool_size":      len(candidates),
-            "multi_view":     score,
-            "single_view":    single_score,
-        })
-    # Summary
-    print("\n" + "=" * 60)
-    print("RETRIEVAL EVAL RESULTS")
-    print(f"{'Difficulty':<16} {'N':>5}  {'R@1':>6}  {'R@5':>6}  {'R@10':>6}  {'Chance R@1':>10}")
-    print("-" * 60)
-    for diff in ["all", "baseline", "easy", "medium", "hard", "very_hard"]:
-        b = by_difficulty[diff]
-        if b["n"] == 0:
-            continue
-        chance = 100.0 / pool_size
-        print(
-            f"{diff:<16} {b['n']:>5}  "
-            f"{b['r1']/b['n']:>5.1%}  "
-            f"{b['r5']/b['n']:>5.1%}  "
-            f"{b['r10']/b['n']:>5.1%}  "
-            f"{chance:>9.1f}%"
-        )
-    output = {
-        "summary": {d: {k: v/b["n"] if k != "n" else v for k, v in b.items()}
-                    for d, b in by_difficulty.items()},
-        "pool_size": pool_size,
-        "n_patents": len(results),
-        "results":   results,
-    }
-    Path(out_path).parent.mkdir(parents=True, exist_ok=True)
-    with open(out_path, "w") as f:
-        json.dump(output, f, indent=2)
-    print(f"\nFull results → {out_path}")
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--embeddings", default="data/embeddings/embeddings_2022_vitl14.parquet")
-    parser.add_argument("--enriched",   default="data/enriched/enriched_2022.parquet")
-    parser.add_argument("--n",          type=int, default=500)
-    parser.add_argument("--pool-size",  type=int, default=100)
-    parser.add_argument("--out",        default="results/retrieval_eval.json")
-    parser.add_argument("--seed",       type=int, default=42)
-    args = parser.parse_args()
-    run_eval(args.embeddings, args.enriched, args.n, args.pool_size, args.out, args.seed)
-if __name__ == "__main__":
-    main()