scripts/eval/retrieval_eval.py

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