File size: 3,870 Bytes
448d6a5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | """Evaluation protocol (Sec 5.2 / App C-D): pairwise win-rate vs expert reference
with 3 judges x 2 order-swaps (6 votes/dim), MOScore (Eq 14), and computable
novelty / diversity metrics (all-MiniLM-L6-v2)."""
from __future__ import annotations
import numpy as np
from . import llm
from .tournament import judge_stage, PF_DIMS, PS_DIMS
from .flow import idea_to_text, motivation_text
from . import supernet as _sn
# MOScore weights (NOT STATED in paper -> uniform, documented)
W_PF = np.array([1 / 3, 1 / 3, 1 / 3])
W_PS = np.array([1 / 3, 1 / 3, 1 / 3])
def moscore(s, w):
s = np.clip(np.asarray(s, dtype=float), 1e-6, 1.0)
w = np.asarray(w, dtype=float)
w = w / w.sum()
arith = float((w * s).sum())
geo = float(np.prod(s ** w))
return 0.5 * (arith + geo)
def _method_win(winner, method_is):
"""winner is 'A'/'B'/None; method_is is which slot the method occupies."""
if winner is None:
return 0.5
return 1.0 if winner == method_is else 0.0
def winrate_vs_reference(method_idea, ref_idea, context, judges, seed=0):
"""Return dict of 6 dims -> win-rate in [0,1] via 3 judges x 2 order swaps.
The (judge, order, stage) calls are independent -> run concurrently."""
votes = {"PF_" + d: [] for d in PF_DIMS}
votes.update({"PS_" + d: [] for d in PS_DIMS})
tasks = [] # (ji, swap, stage)
for ji, jm in enumerate(judges):
for swap in (False, True):
for stage in ("motivation", "idea"):
tasks.append((ji, jm, swap, stage))
def _do(t):
ji, jm, swap, stage = t
A, B = (ref_idea, method_idea) if swap else (method_idea, ref_idea)
off = 7 if stage == "idea" else 0
res = judge_stage(A, B, context, stage, model=jm, seed=seed + ji * 13 + off + swap)
return (swap, stage, res)
outs = llm.parallel_map(_do, tasks, workers=min(12, len(tasks)))
for swap, stage, res in outs:
method_is = "B" if swap else "A"
dims = PF_DIMS if stage == "motivation" else PS_DIMS
pref = "PF_" if stage == "motivation" else "PS_"
for d in dims:
votes[pref + d].append(_method_win(res.get(d), method_is))
return {k: float(np.mean(v)) for k, v in votes.items()}
def aggregate_winrates(per_query_winrates):
"""per_query_winrates: list of dicts -> mean per dim + MOScores + overall."""
dims = list(per_query_winrates[0].keys())
mean = {d: float(np.mean([q[d] for q in per_query_winrates])) for d in dims}
s_pf = [mean["PF_Novelty"], mean["PF_Significance"], mean["PF_Timeliness"]]
s_ps = [mean["PS_Novelty"], mean["PS_Effectiveness"], mean["PS_Feasibility"]]
mo_pf = moscore(s_pf, W_PF)
mo_ps = moscore(s_ps, W_PS)
overall = 0.5 * (mo_pf + mo_ps)
out = dict(mean)
out["MOScore_PF"] = mo_pf
out["MOScore_PS"] = mo_ps
out["Overall"] = overall
return out
# ---- computable metrics -------------------------------------------------------
def _emb(texts):
return _sn.encode(texts, normalize=True)
def novelty(idea, related_works):
"""1 - mean cosine of (motivation, method) vs related works (Eq 17-18)."""
if not related_works:
return float("nan")
rw = _emb(list(related_works))
mot = _emb([motivation_text(idea)])[0]
met = _emb([idea.get("method", "")])[0]
n_m = 1.0 - float(np.mean(rw @ mot))
n_s = 1.0 - float(np.mean(rw @ met))
return 0.5 * (n_m + n_s)
def diversity(ideas):
"""1 - mean pairwise cosine among ideas (motivation & method averaged)."""
if len(ideas) < 2:
return float("nan")
mot = _emb([motivation_text(i) for i in ideas])
met = _emb([i.get("method", "") for i in ideas])
def _div(E):
S = E @ E.T
n = len(E)
off = (S.sum() - np.trace(S)) / (n * (n - 1))
return 1.0 - float(off)
return 0.5 * (_div(mot) + _div(met))
|