Reorganize: scripts/eval/condition_c_text_only.py

scripts/eval/condition_c_text_only.py

@@ -0,0 +1,287 @@
+"""Condition C: Text-only viewpoint identification — no image.
+
+The four conditions being tested across the benchmark:
+  A — Vision only:        VLM sees image, no text
+  B — Drawing program:    LLM sees SVG path tokens, no image  (future)
+  C — Text description:   LLM sees drawing description + numeric features, no image
+  D — Vision + text:      VLM sees image AND drawing description  (future)
+
+This script runs Condition C.
+
+TASK 1 — Viewpoint Identification:
+  Given a representation of a single patent figure, name its viewpoint type
+  (e.g. "front elevational view", "perspective view", "top plan view").
+  Ground truth: viewpoint label parsed from drawing_description text.
+  Scoring: loose keyword overlap (same as Vision condition A).
+  Current Vision (A) result: 23.3% overall, 5.3% on front elevational.
+
+TASK 1 Condition C setup:
+  Input: patent title + full drawing_description with the TARGET FIGURE's viewpoint
+  word MASKED (replaced with ___). The model sees what all OTHER figures show, but
+  must predict what the target figure's viewpoint is.
+  This is FIM (Fill-in-the-Middle) on the drawing description text — exactly
+  analogous to code FIM where prefix/suffix constrain the middle.
+
+  Numeric features (ink_frac, edge_transitions, img_aspect) are also provided
+  as a supplementary signal when available.
+
+TASK 2 — Cross-view Correspondence (text version):
+  Given drawing descriptions of N-1 views of a patent, plus a candidate set of
+  view descriptions (with viewpoint labels masked), identify which candidate is
+  the front elevational view.
+  Currently deferred — Task 2 is broken with the thinking model in the vision
+  condition; running text version here would not be a fair comparison.
+
+Usage:
+    python scripts/eval/condition_c_text_only.py \
+        --enriched data/enriched/enriched_2022.parquet \
+        --sample data/sample/eval_sample.parquet \
+        --n 18 \
+        --out results/condition_c_results.json
+"""
+
+import argparse
+import json
+import re
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import pandas as pd
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+from provider import chat, get_client
+
+# ── viewpoint parsing (shared with track_a) ──────────────────────────────────
+
+def parse_viewpoint(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 mask_viewpoint(desc: str, fig_num: int) -> tuple[str, str]:
+    """Replace the target figure's viewpoint with ___ and return (masked_desc, original_vp)."""
+    pat = re.compile(
+        rf"(FIG\.\s*{fig_num + 1}\s+is\s+(?:a\s+|an\s+)?)(.{{5,80}}?)(\s*(?:view|thereof|;|\n|$))",
+        re.IGNORECASE,
+    )
+    vp = parse_viewpoint(desc, fig_num)
+    masked = pat.sub(r"\1___\3", desc or "", count=1)
+    return masked, vp
+
+
+def viewpoint_match(predicted: str, ground_truth: str) -> bool:
+    DIRECTIONS = {"front","rear","back","left","right","top","bottom","side",
+                  "perspective","plan","elevation","elevational","isometric",
+                  "oblique","reference","detail","enlarged","cross","section"}
+    pred_w = set(re.findall(r"\w+", predicted.lower())) & DIRECTIONS
+    gt_w   = set(re.findall(r"\w+", ground_truth.lower())) & DIRECTIONS
+    if not gt_w:
+        return False
+    return len(pred_w & gt_w) / len(gt_w) >= 0.5
+
+
+VP_BUCKETS = [
+    ("perspective",   lambda v: "perspective" in v),
+    ("front_elev",    lambda v: "front elev" in v),
+    ("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),
+    ("other",         lambda v: True),
+]
+
+def bucket(vp: str) -> str:
+    for name, fn in VP_BUCKETS:
+        if fn(vp):
+            return name
+    return "other"
+
+
+# ── prompt construction ───────────────────────────────────────────────────────
+
+TASK1_C_PROMPT = """\
+You are an engineer reading a US design patent.
+
+Patent title: {title}
+
+The patent has {n_figs} figures. Here is the drawing description with one figure's viewpoint type replaced by ___:
+
+{masked_desc}
+
+{numeric_context}
+
+What type of view is FIG. {fig_num}? Give the viewpoint label only (2-5 words).
+Examples: "front elevational view", "perspective view", "top plan view", "rear elevational view"
+"""
+
+def make_prompt(row: pd.Series) -> str | None:
+    """Build the text-only Task 1 prompt for one figure."""
+    desc = str(row.get("drawing_description") or "")
+    fig_num = int(row.get("figure_number", 0))
+    title = str(row.get("patent_title") or "")
+    n_figs = int(row.get("n_figures_in_patent", 0))
+
+    masked_desc, vp = mask_viewpoint(desc, fig_num)
+    if not vp:
+        return None, None  # can't evaluate without ground truth
+
+    # Numeric context (if available)
+    numeric_parts = []
+    for col, label in [("ink_frac","ink density"), ("edge_transitions","edge transitions"),
+                       ("img_aspect","aspect ratio")]:
+        val = row.get(col)
+        if val is not None and not pd.isna(val):
+            if col == "ink_frac":
+                numeric_parts.append(f"  {label}: {float(val):.2%}")
+            elif col == "edge_transitions":
+                numeric_parts.append(f"  {label}: {int(val):,}")
+            else:
+                numeric_parts.append(f"  {label}: {float(val):.2f}")
+    numeric_context = ("Image statistics for FIG. {}:\n{}".format(fig_num + 1, "\n".join(numeric_parts))
+                       if numeric_parts else "")
+
+    prompt = TASK1_C_PROMPT.format(
+        title=title,
+        n_figs=n_figs,
+        masked_desc=masked_desc.strip(),
+        numeric_context=numeric_context,
+        fig_num=fig_num + 1,
+    )
+    return prompt, vp
+
+
+# ── main ──────────────────────────────────────────────────────────────────────
+
+def run(enriched_path: str, sample_path: str | None, n: int, out_path: str, seed: int = 42):
+    client = get_client()
+
+    df = pd.read_parquet(enriched_path)
+
+    # If sample parquet provided, restrict to those patent_ids
+    if sample_path and Path(sample_path).exists():
+        sample = pd.read_parquet(sample_path)
+        df = df[df["patent_id"].isin(sample["patent_id"].unique())]
+        print(f"Restricted to {df['patent_id'].nunique()} sample patents")
+
+    # Pick same eligible patents as track_a (perspective + front + ≥3 figs)
+    df["vp"] = df.apply(lambda r: parse_viewpoint(r.get("drawing_description",""), r["figure_number"]), axis=1)
+    has_persp = df.groupby("patent_id")["vp"].apply(lambda x: x.str.contains("perspective").any())
+    has_front = df.groupby("patent_id")["vp"].apply(lambda x: (x.str.contains("front elev") | x.isin(["front elevation","front plan"])).any())
+    eligible = has_persp.index[has_persp & has_front].tolist()
+
+    import random
+    rng = random.Random(seed)
+    rng.shuffle(eligible)
+    eval_pids = eligible[:n]
+    print(f"Eligible patents: {len(eligible)}, evaluating: {len(eval_pids)}")
+
+    results = []
+    by_vp = defaultdict(lambda: [0, 0])  # [correct, total]
+    total_correct = total_n = 0
+
+    for pid in eval_pids:
+        group = df[df["patent_id"] == pid].sort_values("figure_number")
+        patent_results = []
+
+        for _, row in group.iterrows():
+            prompt, ground_truth = make_prompt(row)
+            if prompt is None:
+                continue
+
+            # ── TASK 1 (Condition C): text-only viewpoint identification ──────
+            # Input:  masked drawing_description (FIM on text) + numeric features
+            # Output: predicted viewpoint type
+            # No image is shown — this is a pure language model inference task
+            msgs = [{"role": "user", "content": prompt}]
+            predicted = chat(client, msgs, max_tokens=30).lower().strip()
+
+            correct = viewpoint_match(predicted, ground_truth)
+            vp_label = bucket(ground_truth)
+            by_vp[vp_label][1] += 1
+            if correct:
+                by_vp[vp_label][0] += 1
+            total_correct += int(correct)
+            total_n += 1
+
+            patent_results.append({
+                "fig": int(row["figure_number"]),
+                "ground_truth": ground_truth,
+                "predicted": predicted,
+                "correct": correct,
+                "vp_bucket": vp_label,
+            })
+            time.sleep(0.3)
+
+        if patent_results:
+            n_correct = sum(r["correct"] for r in patent_results)
+            results.append({
+                "patent_id": pid,
+                "patent_title": str(group["patent_title"].iloc[0]),
+                "figures": patent_results,
+            })
+            print(f"[{pid}] {str(group['patent_title'].iloc[0])[:45]} — "
+                  f"{n_correct}/{len(patent_results)} correct")
+
+    # ── Summary ───────────────────────────────────────────────────────────────
+    print()
+    print("=" * 60)
+    print("CONDITION C — TEXT-ONLY TASK 1 RESULTS")
+    print("Input: drawing description (FIM, viewpoint masked) + numeric features")
+    print("No image shown")
+    print("=" * 60)
+    print(f"Overall: {total_correct}/{total_n} = {total_correct/max(total_n,1):.1%}")
+    print()
+    print(f"{'Viewpoint':<16} {'Correct':>8} {'Total':>6} {'Acc':>6}")
+    for label, (c, t) in sorted(by_vp.items(), key=lambda x: -x[1][1]):
+        if t == 0: continue
+        print(f"  {label:<14} {c:>8} {t:>6} {c/t:>5.1%}")
+
+    print()
+    print("COMPARISON TABLE")
+    print(f"  Condition A (vision only):    23.3%  overall  |  5.3% front elev")
+    print(f"  Condition C (text only):   {total_correct/max(total_n,1):>5.1%}  overall  |"
+          f"  {by_vp['front_elev'][0]/max(by_vp['front_elev'][1],1):>4.1%} front elev")
+    print(f"  Human baseline (est):         ~95%")
+
+    output = {
+        "condition": "C_text_only",
+        "task": "Task 1 — Viewpoint Identification",
+        "input": "drawing_description (FIM: target viewpoint masked) + numeric features",
+        "no_image": True,
+        "summary": {
+            "overall_acc": total_correct / max(total_n, 1),
+            "n": total_n,
+            "by_viewpoint": {k: {"correct": v[0], "total": v[1], "acc": v[0]/v[1] if v[1] else 0}
+                             for k, v in by_vp.items()},
+        },
+        "results": results,
+        "comparison": {
+            "condition_A_vision_only": {"overall": 0.233, "front_elev": 0.053},
+            "condition_C_text_only": {"overall": total_correct/max(total_n,1),
+                                      "front_elev": by_vp["front_elev"][0]/max(by_vp["front_elev"][1],1)},
+        }
+    }
+    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"\nResults → {out_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--enriched", default="data/enriched/enriched_2022.parquet")
+    parser.add_argument("--sample",   default="data/sample/eval_sample.parquet")
+    parser.add_argument("--n",        type=int, default=18)
+    parser.add_argument("--out",      default="results/condition_c_results.json")
+    args = parser.parse_args()
+    run(args.enriched, args.sample, args.n, args.out)
+
+
+if __name__ == "__main__":
+    main()