scripts/eval/track_a_multiview.py

"""Track A: Multi-view correspondence eval on design patent rasters.

Two tasks:
  Task 1 — Viewpoint identification: given one figure, name the viewpoint.
  Task 2 — Cross-view retrieval: given figure_0, select the correct
            "front elevational" view from 4 candidates (1 correct + 3 distractors
            from other patents in the same Locarno class).

Usage:
    export ANTHROPIC_API_KEY=...
    python scripts/eval/track_a_multiview.py \
        --enriched data/enriched/enriched_2022.parquet \
        --images /tmp/patent_sample/2022 \
        --n 30 \
        --out results/track_a_results.json

Results printed to stdout and saved to --out.
"""

import argparse
import json
import os
import random
import re
import time
from pathlib import Path

import pandas as pd
from PIL import Image
from tqdm import tqdm

from provider import chat, encode_image, get_client, image_message, multi_image_message


# ── viewpoint parsing ────────────────────────────────────────────────────────

VIEWPOINT_RE = re.compile(
    r"FIG\.\s*{n}\s+is\s+(?:a\s+|an\s+)?(.{{5,80}}?)\s*(?:view|thereof|;|\n|$)",
    re.IGNORECASE,
)

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


FRONT_KEYWORDS = {"front elevational", "front view", "front elevation", "front plan"}

def is_front_view(vp: str) -> bool:
    vp = vp.lower()
    return any(k in vp for k in FRONT_KEYWORDS)


def is_perspective_view(vp: str) -> bool:
    return "perspective" in vp.lower()


# ── image loading ─────────────────────────────────────────────────────────────

def find_image_path(images_dir: Path, image_filename: str) -> Path | None:
    """Resolve image_filename → path under images_dir.

    IMPACT stores images as:
        {images_dir}/USD0949851-20220426/USD0949851-20220426-D00001.TIF
    The directory name is the filename prefix up to '-D00'.
    """
    parts = image_filename.split("-D0")
    if len(parts) < 2:
        return None
    dir_name = parts[0]  # e.g. "USD0949851-20220426"
    candidate = images_dir / dir_name / image_filename
    return candidate if candidate.exists() else None


def load_image_b64(path: Path) -> tuple[str, str]:
    return encode_image(path)


# ── Claude API calls ─────────────────────────────────────────────────────────

def ask_viewpoint(client, img_b64: str, media_type: str) -> str:
    """Task 1: identify the viewpoint of a single patent figure."""
    msgs = image_message(img_b64, media_type,
        "This is a technical drawing from a US design patent. "
        "In 2–5 words, what viewpoint or perspective does this figure show? "
        "(e.g. 'front elevational view', 'perspective view', 'top plan view') "
        "Reply with the viewpoint label only, nothing else."
    )
    return chat(client, msgs, max_tokens=80).lower()


def ask_cross_view(
    client,
    query_b64: str,
    query_media: str,
    candidates: list[tuple[str, str]],
    target_label: str = "front elevational view",
) -> int:
    """Task 2: sequential yes/no — ask about each candidate independently.

    Avoids the multi-image A/B/C/D format that causes thinking-model parse
    failures. For each candidate we ask a binary question; the one (and only
    one) that gets YES is the answer. Returns 0-indexed position, or -1 if
    zero or multiple candidates say YES.
    """
    yes_indices = []
    for i, (cand_b64, cand_media) in enumerate(candidates):
        msgs = multi_image_message(
            images=[(query_b64, query_media), (cand_b64, cand_media)],
            text_after=(
                f"Image 1 is a perspective view of a design patent object. "
                f"Image 2 is another figure from the same patent. "
                f"Is Image 2 the {target_label} of this object? "
                f"Reply with YES or NO only."
            ),
        )
        answer = chat(client, msgs, max_tokens=10).upper().strip()
        is_yes = answer.startswith("YES")
        if is_yes:
            yes_indices.append(i)
        time.sleep(0.3)

    if len(yes_indices) == 1:
        return yes_indices[0]
    # Ambiguous (0 or >1 YES): fall back to the first YES if multiple,
    # or -1 if none.
    return yes_indices[0] if yes_indices else -1


# ── scoring helpers ───────────────────────────────────────────────────────────

def viewpoint_match(predicted: str, ground_truth: str) -> bool:
    """Loose match: check if key directional words overlap."""
    DIRECTIONS = {"front", "rear", "back", "left", "right", "top", "bottom",
                  "side", "perspective", "plan", "elevation", "elevational",
                  "isometric", "oblique", "reference", "detail"}
    pred_words = set(re.findall(r"\w+", predicted.lower())) & DIRECTIONS
    gt_words = set(re.findall(r"\w+", ground_truth.lower())) & DIRECTIONS
    if not gt_words:
        return False
    return len(pred_words & gt_words) / len(gt_words) >= 0.5


# ── dataset preparation ───────────────────────────────────────────────────────

def build_sample_pool(df: pd.DataFrame, images_dir: Path) -> pd.DataFrame:
    """Enrich dataframe with parsed viewpoints and resolved image paths."""
    df = df.copy()
    df["viewpoint_parsed"] = df.apply(
        lambda r: parse_viewpoint(r.get("drawing_description", ""), r["figure_number"]),
        axis=1,
    )
    df["image_path"] = df["image_filename"].apply(
        lambda fn: find_image_path(images_dir, fn)
    )
    return df


def select_patents(df: pd.DataFrame, n: int, seed: int = 42) -> list[str]:
    """Select n patents that have: ≥3 figures, a perspective view, and a front view."""
    rng = random.Random(seed)
    eligible = []
    for patent_id, group in df.groupby("patent_id"):
        vps = group["viewpoint_parsed"].tolist()
        paths = group["image_path"].tolist()
        has_perspective = any(is_perspective_view(v) for v in vps)
        has_front = any(is_front_view(v) for v in vps)
        all_images = all(p is not None for p in paths)
        if has_perspective and has_front and all_images and len(group) >= 3:
            eligible.append(patent_id)
    rng.shuffle(eligible)
    print(f"Eligible patents: {len(eligible)}, selecting {min(n, len(eligible))}")
    return eligible[:n]


# ── main eval loop ────────────────────────────────────────────────────────────

def run_eval(
    enriched_path: str,
    images_dir: str,
    n: int,
    out_path: str,
    seed: int = 42,
):
    client = get_client()
    images_dir = Path(images_dir)

    print("Loading enriched data...")
    df = pd.read_parquet(enriched_path)
    df = build_sample_pool(df, images_dir)

    patents = select_patents(df, n, seed=seed)
    if not patents:
        print("ERROR: No eligible patents found. Check images_dir and enriched data.")
        return

    # Build distractor pool keyed by Locarno class
    class_to_patent = {}
    for pid, g in df.groupby("patent_id"):
        cls = g["locarno_class"].iloc[0] if "locarno_class" in g.columns else "unknown"
        class_to_patent.setdefault(cls, []).append(pid)

    results = []
    t1_correct = t1_total = 0
    t2_correct = t2_total = 0

    for patent_id in tqdm(patents, desc="Evaluating patents"):
        group = df[df["patent_id"] == patent_id].sort_values("figure_number")
        rows = group.to_dict("records")

        # Pick perspective (query) and front (target) rows
        perspective_row = next((r for r in rows if is_perspective_view(r["viewpoint_parsed"])), None)
        front_rows = [r for r in rows if is_front_view(r["viewpoint_parsed"])]
        if not perspective_row or not front_rows:
            continue
        front_row = front_rows[0]

        # ── Task 1: viewpoint identification on every figure ────────────────
        t1_results = []
        for row in rows:
            if not row["image_path"]:
                continue
            b64, media = load_image_b64(row["image_path"])
            predicted = ask_viewpoint(client, b64, media)
            correct = viewpoint_match(predicted, row["viewpoint_parsed"])
            t1_results.append({
                "fig": row["figure_number"],
                "ground_truth": row["viewpoint_parsed"],
                "predicted": predicted,
                "correct": correct,
            })
            t1_total += 1
            t1_correct += int(correct)
            time.sleep(0.3)  # rate limit courtesy

        # ── Task 2: pick front view from 4 options ───────────────────────────
        query_b64, query_media = load_image_b64(perspective_row["image_path"])

        # Build 3 distractors: front views from other patents in same Locarno class
        cls = group["locarno_class"].iloc[0] if "locarno_class" in group.columns else "unknown"
        distractor_pids = [p for p in class_to_patent.get(cls, []) if p != patent_id]
        random.Random(seed + hash(patent_id)).shuffle(distractor_pids)

        distractors = []
        for dpid in distractor_pids:
            dg = df[df["patent_id"] == dpid]
            dfront = dg[dg["viewpoint_parsed"].apply(is_front_view)]
            if not dfront.empty and dfront.iloc[0]["image_path"]:
                distractors.append(dfront.iloc[0]["image_path"])
            if len(distractors) == 3:
                break

        if len(distractors) < 3:
            # Fall back to any other patent's figure
            other_pids = [p for p in df["patent_id"].unique() if p != patent_id]
            random.Random(seed).shuffle(other_pids)
            for op in other_pids:
                og = df[df["patent_id"] == op]
                if og.iloc[0]["image_path"]:
                    distractors.append(og.iloc[0]["image_path"])
                if len(distractors) == 3:
                    break

        if len(distractors) < 3:
            continue

        # Insert correct answer at random position
        rng = random.Random(seed + hash(patent_id) + 1)
        correct_pos = rng.randint(0, 3)
        candidate_paths = distractors[:3]
        candidate_paths.insert(correct_pos, front_row["image_path"])

        candidates = [load_image_b64(p) for p in candidate_paths]
        chosen = ask_cross_view(client, query_b64, query_media, candidates)

        t2_correct += int(chosen == correct_pos)
        t2_total += 1

        result = {
            "patent_id": patent_id,
            "patent_title": group["patent_title"].iloc[0] if "patent_title" in group.columns else "",
            "locarno_class": cls,
            "task1": t1_results,
            "task2": {
                "correct_pos": correct_pos,
                "model_choice": chosen,
                "correct": chosen == correct_pos,
            },
        }
        results.append(result)

        # Print running totals
        print(f"\n[{patent_id}] {result['patent_title'][:50]}")
        print(f"  T1: {sum(r['correct'] for r in t1_results)}/{len(t1_results)} viewpoints correct")
        print(f"  T2: {'✓' if result['task2']['correct'] else '✗'} (chose {chosen}, correct was {correct_pos})")
        print(f"  Running: T1={t1_correct}/{t1_total} ({t1_correct/max(t1_total,1):.0%})  "
              f"T2={t2_correct}/{t2_total} ({t2_correct/max(t2_total,1):.0%})")

        time.sleep(0.5)

    # ── Summary ───────────────────────────────────────────────────────────────
    print("\n" + "=" * 60)
    print("RESULTS SUMMARY")
    print("=" * 60)
    print(f"Task 1 — Viewpoint identification: {t1_correct}/{t1_total} = {t1_correct/max(t1_total,1):.1%}")
    print(f"Task 2 — Cross-view retrieval:     {t2_correct}/{t2_total} = {t2_correct/max(t2_total,1):.1%}")
    print(f"Chance baseline (Task 2):          1/4 = 25.0%")
    print(f"Human baseline (Task 2):           ~95% (estimated)")

    output = {
        "summary": {
            "task1_acc": t1_correct / max(t1_total, 1),
            "task2_acc": t2_correct / max(t2_total, 1),
            "task1_n": t1_total,
            "task2_n": t2_total,
        },
        "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}")


# ── CLI ───────────────────────────────────────────────────────────────────────

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("--n", type=int, default=30)
    parser.add_argument("--out", default="results/track_a_results.json")
    parser.add_argument("--seed", type=int, default=42)
    args = parser.parse_args()
    run_eval(args.enriched, args.images, args.n, args.out, args.seed)


if __name__ == "__main__":
    main()