tirtho149's picture
MACE-Bench release: images, memory banks, captions, predictions, traces, code
c8e03af verified
Raw History Blame Contribute Delete
23.8 kB
"""All extension statistics from raw rows; no model call. Protocol: EXPERIMENT_PROTOCOL.md.
python -m experiments.mace_extension.scripts.analyze select # calibration only: writes configurations/fallback_rule.json
python -m experiments.mace_extension.scripts.analyze all # needs the frozen rule; writes statistics/ and tables/
"""
from __future__ import annotations
import json
import math
import sys
from collections import Counter
from pathlib import Path
import numpy as np
import pandas as pd
from agmem import data, llm, packet
from mace10 import jobs as JB, results as R
from . import jobs as X
ROOT = Path(__file__).resolve().parent.parent
RAW, ST, TB, CFG, PR = ROOT / "raw_results", ROOT / "statistics", ROOT / "tables", ROOT / "configurations", ROOT / "processed_results"
SIGS_Q = ["bm25_top1", "bm25_margin", "bm25_conc", "dino_top1", "dino_margin"]
SIGS_G = {"bm25_agree": (0.5, 0.75, 1.0), "dino_agree": (0.5, 0.75, 1.0), "cross_agree": (0.25, 0.5, 0.75, 1.0)}
QS = [round(0.05 * i, 2) for i in range(1, 11)]
FOCUS = ["Apple", "Grape", "Potato", "Wheat"]
def rows(name):
p = RAW / name / "predictions.jsonl"
return pd.DataFrame(map(json.loads, p.open())) if p.exists() else pd.DataFrame()
def caption(i, crop):
p = llm.C.CACHE / "llm" / f"{JB.caption_key(i, crop)}.json"
r = json.loads(p.read_text()); c = llm.parse_json(r["text"])
return c if isinstance(c, dict) else {}
_caps = {}
def cap(i, crop):
if i not in _caps:
_caps[i] = caption(i, crop)
return _caps[i]
def dino():
a = np.load(JB.OUT / "dinov2_embeddings.npz"); b = np.load(PR / "dinov2_extra.npz")
E = np.concatenate([a["E"], b["E"]]).astype(np.float32); E /= np.linalg.norm(E, axis=1, keepdims=True)
return E, {k: i for i, k in enumerate(list(a["ids"]) + list(b["ids"]))}
def bm25_raw(query, docs):
"""packet.bm25 before its division by the maximum."""
N = len(docs) or 1
df = Counter(t for d in docs.values() for t in set(d)); avg = sum(len(d) for d in docs.values()) / N
q = Counter(query); out = {}
for k, d in docs.items():
tf = Counter(d); s = 0.0
for t in q:
if t in tf:
s += math.log(1 + (N - df[t] + 0.5) / (df[t] + 0.5)) * tf[t] * 2.2 / (tf[t] + 1.2 * (0.25 + 0.75 * len(d) / avg))
out[k] = s
return out
def modal_share(labs):
return max(Counter(labs).values()) / len(labs) if labs else 0.0
def signals(qid, crop, bank, E, idx):
"""bank: list of {image_id, label}. Uses no query label."""
qc = cap(qid, crop); q = packet.tok(packet.caption_text(qc)) + packet.tok(str(qc.get("organ", ""))) * 3
lab = {m["image_id"]: m["label"] for m in bank}
raw = bm25_raw(q, {i: packet.tok(packet.caption_text(cap(i, crop))) for i in lab})
top = sorted(raw, key=lambda k: (-raw[k], k))[:4]; v = [raw[k] for k in top] + [0, 0]
ids = sorted(lab); s = E[[idx[i] for i in ids]] @ E[idx[qid]]
o = sorted(range(len(ids)), key=lambda n: (-s[n], ids[n]))[:4]; dtop = [ids[n] for n in o]; c = [float(s[n]) for n in o] + [0, 0]
bl, dl = [lab[i] for i in top], [lab[i] for i in dtop]
return {"bm25_top1": v[0], "bm25_margin": v[0] - v[1], "bm25_conc": v[0] / (sum(v[:4]) or 1), "bm25_agree": modal_share(bl), "dino_top1": c[0], "dino_margin": c[0] - c[1],
"dino_agree": modal_share(dl), "cross_agree": sum(x in set(dl) for x in bl) / max(1, len(bl)), "bm25_ids": top, "bm25_labels": bl, "dino_ids": dtop, "dino_labels": dl}
def eq(df, col):
return float(df.groupby("crop")[col].mean().mean() * 100)
def contrast(d, plus, minus=(), name=""):
"""Equal-crop linear contrast with a paired bootstrap. plus/minus: column names."""
plus, minus = list(plus), list(minus); cols = list(dict.fromkeys(plus + minus))
bs = R.fast_boot(d, cols); v = sum(bs[c] for c in plus) - sum((bs[c] for c in minus), np.zeros(R.B))
est = sum(eq(d, c) for c in plus) - sum(eq(d, c) for c in minus)
p = min(1.0, 2 * min((v <= 0).mean(), (v >= 0).mean()) + 1 / R.B)
return {"name": name, "est": est, "ci": R.ci(v), "p_boot": float(p), "n": int(len(d))}
def family(items):
for x, h in zip(items, R.holm([i["p_boot"] for i in items])):
x["p_holm"] = float(h)
return items
def reading(c):
lo, hi = c["ci"]
return "positive" if lo > 0 and hi > 3 else "negative" if hi < 0 and lo < -3 else "within 3 points" if lo >= -3 and hi <= 3 else "inconclusive"
def select():
"""Choose one fallback rule on calibration rows only."""
D = rows("E3cal"); assert len(D) == 1800, len(D)
E, idx = dino(); recs = []
W = D.pivot_table(index="image_id", columns="condition", values="correct", aggfunc="first").astype(float)
meta = D.drop_duplicates("image_id").set_index("image_id")
for i, r in meta.iterrows():
for bankname, variant in (("mixed", "mixed"), ("other", "other_source")):
b = JB.mem(r.crop, 0, int(r.run), 4, variant, r.collection if variant != "mixed" else None)
s = signals(i, r.crop, b, E, idx)
recs.append({"image_id": i, "crop": r.crop, "bank": bankname, "sage": W.loc[i, "sage"], "mem": W.loc[i, "mace" if bankname == "mixed" else "mace_other"], **{k: v for k, v in s.items() if not isinstance(v, list)}})
C = pd.DataFrame(recs); C.to_csv(PR / "calibration_signals.csv", index=False)
def score(use):
x = C.assign(a=np.where(use, C.mem, C.sage))
return float(np.mean([x[x.bank == b].groupby("crop").a.mean().mean() * 100 for b in ("mixed", "other")]))
grid = []
for s in SIGS_Q:
for q in QS:
t = C.groupby("crop")[s].quantile(q)
use = C[s] >= C.crop.map(t)
grid.append({"signal": s, "kind": "crop_quantile", "value": q, "cal_score": score(use), "cal_fallback": float(1 - use.mean()), "thresholds": t.to_dict()})
for s, ts in SIGS_G.items():
for t in ts:
use = C[s] >= t
grid.append({"signal": s, "kind": "global", "value": t, "cal_score": score(use), "cal_fallback": float(1 - use.mean()), "thresholds": None})
always = score(np.ones(len(C), bool)); never = score(np.zeros(len(C), bool))
G = pd.DataFrame(grid).sort_values(["cal_score", "cal_fallback"], ascending=[False, True]); best = G.iloc[0].to_dict()
G.drop(columns="thresholds").to_csv(TB / "fallback_calibration_grid.csv", index=False)
rule = {"chosen_on": "calibration rows only", "always_mace_cal": always, "always_sage_cal": never, "rule": best, "beats_always_mace": bool(best["cal_score"] > always),
"by_bank": {b: {"mem": eq(C[C.bank == b], "mem"), "sage": eq(C[C.bank == b], "sage")} for b in ("mixed", "other")}}
(CFG / "fallback_rule.json").write_text(json.dumps(rule, indent=1, default=float))
print(json.dumps({k: v for k, v in rule.items() if k != "rule"}, indent=1), {k: v for k, v in best.items() if k != "thresholds"})
print(G.drop(columns="thresholds").head(12).round(3).to_string()); print(G.groupby("signal").cal_score.max().round(2).to_string())
def table():
W = R.wide(); H = W[W.hero].copy().set_index("image_id")
for name, col, cond in (("E2", "dino_mace", "dino_mace"), ("E1_haiku", "h_sage", "sage"), ("E1_haiku", "h_mace", "mace"), ("E1_haiku", "h_labels", "labels"), ("E4other", "other_full", "other_source"), ("E4family", "family", "family_disjoint")):
D = rows(name)
if len(D):
H[col] = D[D.condition == cond].drop_duplicates("image_id").set_index("image_id").correct.astype(float)
if "family" in H:
H["family"] = H.family.fillna(H.other_full)
return H.reset_index()
def flips(d, a, b):
"""a is the reference (SAGE), b the memory method. Rates in % of queries, equal-crop."""
g = d.groupby("crop")
return {"corrected": float(g.apply(lambda x: ((x[a] == 0) & (x[b] == 1)).mean()).mean() * 100), "introduced": float(g.apply(lambda x: ((x[a] == 1) & (x[b] == 0)).mean()).mean() * 100)}
def ledger():
L = pd.DataFrame(map(json.loads, (R.RUNS / "cost_ledger.jsonl").open()))
L = L[~L.cache_hit.astype(bool)]
return L[L.failed.fillna(False) == False] if "failed" in L else L # noqa: E712
def use_stats(L, prefix):
g = L[L.tag.fillna("").str.startswith(prefix)]
return {"calls": int(len(g)), "usd": float(g.cost_usd.sum()), "mean_usd": float(g.cost_usd.mean()) if len(g) else None, "median_s": float(g.elapsed_s.median()) if len(g) else None,
"mean_in": float(g.input_tokens.mean()) if len(g) else None, "mean_out": float(g.output_tokens.mean()) if len(g) else None}
def e1(H, L):
out = {"accuracy": {}, "per_crop": {}, "contrasts": [], "flips": {}, "usage": {}}
M = {"Sonnet": ("sage", "mace", "labels_all"), "Haiku": ("h_sage", "h_mace", "h_labels")}
for sp in ("iid", "ood"):
d = H[H.split == sp]; out["accuracy"][sp] = {}
for m, cols in M.items():
bs = R.fast_boot(d, list(cols))
out["accuracy"][sp][m] = {c: {"acc": eq(d, c), "ci": R.ci(bs[c])} for c in cols}
out["flips"][f"{m}_{sp}"] = {"mace_vs_sage": flips(d, cols[0], cols[1]), "mace_vs_labels": flips(d, cols[2], cols[1])}
out["per_crop"][sp] = {c: {k: float(g[k].mean() * 100) for k in M["Sonnet"] + M["Haiku"]} for c, g in d.groupby("crop")}
F = []
for sp in ("iid", "ood"):
d = H[H.split == sp]
F += [contrast(d, ["h_mace"], ["h_sage"], f"haiku_mace_minus_sage_{sp}"), contrast(d, ["h_mace"], ["h_labels"], f"haiku_mace_minus_labels_{sp}")]
out["contrasts"] = family(F)
out["sonnet_reference"] = [contrast(H[H.split == sp], ["mace"], [b], f"sonnet_mace_minus_{b}_{sp}") for sp in ("iid", "ood") for b in ("sage", "labels_all")]
out["model_gap"] = [contrast(H[H.split == sp], ["mace", "h_sage"], ["sage", "h_mace"], f"sonnet_gain_minus_haiku_gain_{sp}") for sp in ("iid", "ood")]
for c in ("sage", "mace", "labels"):
out["usage"][c] = use_stats(L, f"E1_haiku|{c}|")
out["crops_gain"] = {sp: {m: {"up": int(sum(v[M[m][1]] > v[M[m][0]] for v in out["per_crop"][sp].values())), "tied": int(sum(v[M[m][1]] == v[M[m][0]] for v in out["per_crop"][sp].values())),
"down": int(sum(v[M[m][1]] < v[M[m][0]] for v in out["per_crop"][sp].values()))} for m in M} for sp in ("iid", "ood")}
out["unknown"] = {c: int((rows("E1_haiku").query("condition==@c").prediction == "UNKNOWN").sum()) for c in ("sage", "mace", "labels")}
return out
def e2(H, L):
out = {"cells": {}, "per_crop": {}}; cols = ["labels_all", "mace", "dino_labels", "dino_mace"]; F = []
for sp in ("iid", "ood"):
d = H[H.split == sp]; bs = R.fast_boot(d, cols)
out["cells"][sp] = {c: {"acc": eq(d, c), "ci": R.ci(bs[c])} for c in cols}
F += [contrast(d, ["mace"], ["labels_all"], f"caption_under_bm25_{sp}"), contrast(d, ["dino_mace"], ["dino_labels"], f"caption_under_dino_{sp}"),
contrast(d, ["dino_mace"], ["mace"], f"dino_minus_bm25_with_captions_{sp}"), contrast(d, ["dino_mace", "labels_all"], ["dino_labels", "mace"], f"interaction_{sp}")]
out["per_crop"][sp] = {c: {"cap_bm25": float((g.mace - g.labels_all).mean() * 100), "cap_dino": float((g.dino_mace - g.dino_labels).mean() * 100), "dino_minus_bm25_caps": float((g.dino_mace - g.mace).mean() * 100)} for c, g in d.groupby("crop")}
out[f"ret_no_caps_{sp}"] = contrast(d, ["dino_labels"], ["labels_all"], f"dino_minus_bm25_labels_{sp}")
out[f"main_caption_{sp}"] = contrast(d, ["mace", "dino_mace"], ["labels_all", "dino_labels"], f"main_caption_x2_{sp}")
out[f"main_retrieval_{sp}"] = contrast(d, ["dino_mace", "dino_labels"], ["mace", "labels_all"], f"main_retrieval_x2_{sp}")
out["contrasts"] = family(F)
for c in F:
c["reading"] = reading(c)
out["crops_positive"] = {sp: {k: {"up": sum(v[k] > 0 for v in out["per_crop"][sp].values()), "down": sum(v[k] < 0 for v in out["per_crop"][sp].values())} for k in ("cap_bm25", "cap_dino")} for sp in ("iid", "ood")}
out["usage"] = use_stats(L, "E2|")
return out
def e3(H, L):
rule = json.loads((CFG / "fallback_rule.json").read_text()); b = rule["rule"]; E, idx = dino()
S = []
Q = JB.queries().set_index("image_id")
for r in H.itertuples():
s = signals(r.image_id, r.crop, JB.mem(r.crop, 0, int(Q.loc[r.image_id, "run_s0"]), 4), E, idx)
S.append({"image_id": r.image_id, **{k: v for k, v in s.items() if not isinstance(v, list)}, "bm25_ids": s["bm25_ids"]})
S = pd.DataFrame(S).set_index("image_id"); P1 = R.load("P1"); M = P1[P1.condition == "mace"].set_index("image_id")
check = float(np.mean([["m_" + i for i in S.loc[q, "bm25_ids"]] == M.loc[q, "memory_ids"] for q in S.index]))
D = H.set_index("image_id").join(S.drop(columns="bm25_ids"))
th = b["thresholds"]
use = D[b["signal"]] >= (D.crop.map(th) if b["kind"] == "crop_quantile" else b["value"])
D["adaptive"] = np.where(use, D.mace, D.sage); D["oracle"] = np.where(D.hit == 1, D.mace, D.sage); D["fallback"] = (~use).astype(float); D = D.reset_index()
out = {"bm25_rank_reproduced": check, "rule": {k: v for k, v in b.items() if k != "thresholds"}, "acc": {}, "per_crop": {}, "avoid": {}}; F = []
for sp in ("iid", "ood"):
d = D[D.split == sp]; bs = R.fast_boot(d, ["sage", "mace", "adaptive", "oracle"])
out["acc"][sp] = {c: {"acc": eq(d, c), "ci": R.ci(bs[c])} for c in ("sage", "mace", "adaptive", "oracle")}
F.append(contrast(d, ["adaptive"], ["mace"], f"adaptive_minus_mace_{sp}"))
fb = d[d.fallback == 1]
out["avoid"][sp] = {"fallback_rate": float(d.fallback.mean() * 100), "n_fallback": int(len(fb)), "sage_right_mace_wrong_total": int(((d.sage == 1) & (d.mace == 0)).sum()), "avoided": int(((fb.sage == 1) & (fb.mace == 0)).sum()),
"introduced": int(((fb.sage == 0) & (fb.mace == 1)).sum()), "fallback_on_miss": float((fb.hit == 0).mean() * 100) if len(fb) else None, "miss_rate": float((d.hit == 0).mean() * 100)}
for nm, g in (("hit", d[d.hit == 1]), ("miss", d[d.hit == 0])):
out["avoid"][sp][nm] = {c: float(g[c].mean() * 100) for c in ("sage", "mace", "adaptive")} | {"n": int(len(g))}
out["per_crop"][sp] = {c: {k: float(g[k].mean() * 100) for k in ("sage", "mace", "adaptive", "fallback")} for c, g in d.groupby("crop")}
out["contrasts"] = family(F)
# how well each signal separates retrieval misses and harmful memory, post hoc
H2 = D.assign(harm=((D.sage == 1) & (D.mace == 0)).astype(float)); auc = {}
for s in SIGS_Q + list(SIGS_G):
auc[s] = {}
for sp in ("iid", "ood"):
g = H2[H2.split == sp]; r = g.groupby("crop")[s].rank(pct=True)
for tgt, y in (("miss", g.hit == 0), ("harm", g.harm == 1)):
a, c = r[y], r[~y]
auc[s][f"{tgt}_{sp}"] = float((a.values[:, None] < c.values[None, :]).mean() + 0.5 * (a.values[:, None] == c.values[None, :]).mean()) if len(a) else None
out["auc_low_signal_predicts"] = auc
out["usage_per_call"] = {c: use_stats(L, f"P1|{c}|") for c in ("sage", "mace")}
D[["image_id", "crop", "split", "fallback", "adaptive", "oracle", "sage", "mace", "hit"] + SIGS_Q + list(SIGS_G)].to_csv(PR / "hero_fallback.csv", index=False)
return out
def e4(H, L):
I = data.images(); E, idx = dino(); O = rows("E4other").set_index("image_id"); Fm = rows("E4family").set_index("image_id")
iid = H[H.split == "iid"].copy().set_index("image_id")
bank = {q: list(zip(O.loc[q, "memory_bank_ids"], [I.loc[m, "class"] for m in O.loc[q, "memory_bank_ids"]])) for q in iid.index}
iid["covered"] = [float(iid.loc[q, "label"] in {l for _, l in bank[q]}) for q in iid.index]
iid["other_hit"] = [float(iid.loc[q, "label"] in (O.loc[q, "memory_labels_shown"] or [])) for q in iid.index]
def nn(q):
ids = [i for i, _ in bank[q]]; s = E[[idx[i] for i in ids]] @ E[idx[q]]; return bank[q][int(np.argmax(s))][1]
iid["dino_other"] = [float(nn(q) == iid.loc[q, "label"]) for q in iid.index]
iid["bank_n_other"] = [len(bank[q]) for q in iid.index]
iid["fam_n"] = [len(Fm.loc[q, "memory_bank_ids"]) if q in Fm.index else len(bank[q]) for q in iid.index]
d = iid.reset_index(); cov = d[d.covered == 1]; unc = d[d.covered == 0]
out = {"n": {"iid": len(d), "covered": len(cov), "not_covered": len(unc)}, "coverage_by_crop": d.groupby("crop").covered.mean().mul(100).round(1).to_dict(), "acc": {}}
cols = ["sage", "mace", "other_full", "family", "dino_s0", "dino_other"]
for nm, g in (("all", d), ("covered", cov), ("not_covered", unc)):
cc = [c for c in cols]; bs = R.fast_boot(g, cc)
out["acc"][nm] = {c: {"acc": eq(g, c), "ci": R.ci(bs[c])} for c in cc} | {"crops": int(g.crop.nunique()), "n": len(g)}
F = [contrast(d, ["other_full"], ["mace"], "other_minus_standard_all"), contrast(cov, ["other_full"], ["mace"], "other_minus_standard_covered"), contrast(cov, ["other_full"], ["sage"], "other_minus_sage_covered")]
out["contrasts"] = family(F)
out["secondary"] = [contrast(d, ["family"], ["other_full"], "family_minus_other_all"), contrast(cov, ["family"], ["other_full"], "family_minus_other_covered"), contrast(unc, ["other_full"], ["sage"], "other_minus_sage_not_covered"), contrast(d, ["other_full"], ["sage"], "other_minus_sage_all")]
# P5 reconstruction
src = H[H.source & (H.split == "iid")]
out["p5_reconstruction"] = contrast(src, ["same_source"], ["other_source"], "same_minus_other_199")
# per crop source table
T = []
for crop, g in H.groupby("crop"):
a, b = g[g.split == "iid"], g[g.split == "ood"]; x = d[d.crop == crop]; xc = x[x.covered == 1]
I_c = I[I.crop == crop]; p = I_c[(I_c.role == "iid") & I_c["class"].isin(b.label.unique())]["class"].value_counts(normalize=True); q = b.label.value_counts(normalize=True)
ks = sorted(set(p.index) | set(q.index)); pv, qv = p.reindex(ks).fillna(0).values, q.reindex(ks).fillna(0).values; m = (pv + qv) / 2
kl = lambda u, v: float(np.sum(np.where(u > 0, u * np.log2(np.where(u > 0, u, 1) / np.where(v > 0, v, 1)), 0)))
cosI = [float(np.max(E[[idx[i] for i in X.bank_ids(crop, int(r.run_s0))]] @ E[idx[r.image_id]])) for r in a.itertuples()]
cosO = [float(np.max(E[[idx[i] for i in X.bank_ids(crop, int(r.run_s0))]] @ E[idx[r.image_id]])) for r in b.itertuples()]
T.append({"crop": crop, "ood_collection": b.collection.iloc[0], "sage_iid": a.sage.mean() * 100, "mace_iid": a.mace.mean() * 100, "sage_ood": b.sage.mean() * 100, "mace_ood": b.mace.mean() * 100,
"gain_iid": (a.mace - a.sage).mean() * 100, "gain_ood": (b.mace - b.sage).mean() * 100, "hit_iid": a.hit.mean() * 100, "hit_ood": b.hit.mean() * 100,
"other_acc": x.other_full.mean() * 100, "other_hit": x.other_hit.mean() * 100, "covered": x.covered.mean() * 100, "std_cov_stratum": xc.mace.mean() * 100, "other_cov_stratum": xc.other_full.mean() * 100,
"js_bits": 0.5 * kl(pv, m) + 0.5 * kl(qv, m), "dino_nn_iid": float(np.mean(cosI)), "dino_nn_ood": float(np.mean(cosO))})
T = pd.DataFrame(T); T["dino_gap"] = T.dino_nn_iid - T.dino_nn_ood; T["hit_drop"] = T.hit_iid - T.hit_ood; T["gain_drop"] = T.gain_iid - T.gain_ood
T.round(2).to_csv(TB / "table_D_collection_shift.csv", index=False)
sp = lambda a, b: float(T[[a, b]].corr(method="spearman").iloc[0, 1])
out["crop_correlations_spearman_n10"] = {"dino_gap_vs_hit_drop": sp("dino_gap", "hit_drop"), "dino_gap_vs_gain_ood": sp("dino_gap", "gain_ood"), "js_vs_hit_drop": sp("js_bits", "hit_drop"), "js_vs_gain_ood": sp("js_bits", "gain_ood"), "hit_ood_vs_gain_ood": sp("hit_ood", "gain_ood")}
# failure categories on held-out, from saved MACE rows
P1 = R.load("P1"); Mc = P1[P1.condition == "mace"].set_index("image_id"); fc = []
for r in H[H.split == "ood"].itertuples():
m = Mc.loc[r.image_id]; labs = m.memory_labels_shown; pred = m.prediction
cat = "correct" if r.mace == 1 else ("miss_followed_memory" if r.label not in labs and pred in labs else "miss_other" if r.label not in labs else "hit_overruled_to_memory" if pred in labs else "hit_overruled_elsewhere")
fc.append({"crop": r.crop, "category": cat, "harm": r.sage == 1 and r.mace == 0, "rescued": r.sage == 0 and r.mace == 1})
Fc = pd.DataFrame(fc); ct = (Fc.groupby(["crop", "category"]).size().unstack(fill_value=0)); ct["harm"] = Fc.groupby("crop").harm.sum(); ct["rescued"] = Fc.groupby("crop").rescued.sum()
ct.to_csv(TB / "failure_categories_heldout.csv"); out["failure_categories"] = ct.to_dict(orient="index")
# retrieved collection vs query collection, IID standard bank (association only)
rr = []
for r in H[H.split == "iid"].itertuples():
ids = [x[2:] for x in Mc.loc[r.image_id, "memory_ids"]]; rr.append({"crop": r.crop, "same_share": float(np.mean([I.loc[i, "collection"] == r.collection for i in ids])), "top1_same": float(I.loc[ids[0], "collection"] == r.collection), "hit": r.hit, "mace": r.mace, "sage": r.sage,
"bank_same": float(np.mean([I.loc[i, "collection"] == r.collection for i in X.bank_ids(r.crop, int(r.run_s0))]))})
Rr = pd.DataFrame(rr)
out["retrieved_collection"] = {"retrieved_same_share": float(Rr.same_share.mean() * 100), "bank_same_share": float(Rr.bank_same.mean() * 100), "by_top1_same": {str(k): {"n": int(len(g)), "hit": float(g.hit.mean() * 100), "mace": float(g.mace.mean() * 100), "sage": float(g.sage.mean() * 100)} for k, g in Rr.groupby("top1_same")}}
out["usage"] = use_stats(L, "E4other|")
out["bank_size"] = {"other_mean": float(d.bank_n_other.mean()), "family_mean": float(d.fam_n.mean()), "family_rows_changed": int(len(Fm))}
d.to_csv(PR / "hero_iid_cross_collection.csv", index=False)
return out
def dedup(H):
z = np.load(data.C.DATA / "audit/clip_vitb32_embeddings.npz"); E = z["E"].astype(np.float32); E /= np.linalg.norm(E, axis=1, keepdims=True); idx = {k: i for i, k in enumerate(z["ids"])}
I = data.images(); Q = JB.queries().set_index("image_id"); v = []
for r in H.itertuples():
ids = X.bank_ids(r.crop, int(Q.loc[r.image_id, "run_s0"])); s = E[[idx[i] for i in ids]] @ E[idx[r.image_id]]; lab = np.array([I.loc[i, "class"] for i in ids])
v.append(float(s[lab != r.label].max()) if (lab != r.label).any() else -1.0)
H = H.assign(max_diff=v); out = {}
for t in (None, 0.90, 0.85):
g = H if t is None else H[H.max_diff < t]; key = "all" if t is None else f"drop_ge_{t}"; out[key] = {}
for sp in ("iid", "ood"):
d = g[g.split == sp]
out[key][sp] = {"n": int(len(d)), "removed": int((H.split == sp).sum() - len(d)), "sage": eq(d, "sage"), "mace": eq(d, "mace"), "dino_s0": eq(d, "dino_s0"), "mace_minus_sage": contrast(d, ["mace"], ["sage"]), "mace_minus_labels": contrast(d, ["mace"], ["labels_all"])}
for sp in ("iid", "ood"):
d = H[(H.split == sp) & (H.max_diff >= 0.90)]
out[f"flagged_{sp}"] = {"n": int(len(d)), "mace": float(d.mace.mean() * 100), "sage": float(d.sage.mean() * 100), "dino_s0": float(d.dino_s0.mean() * 100)}
return out
def main():
ST.mkdir(exist_ok=True); TB.mkdir(exist_ok=True)
if sys.argv[1] == "select":
return select()
H = table(); L = ledger()
H.to_csv(PR / "hero_all_methods.csv", index=False)
counts = {c: int(H[c].notna().sum()) for c in ("sage", "mace", "labels_all", "dino_labels", "dino_mace", "h_sage", "h_mace", "h_labels", "other_full", "family")}
S = {"row_counts": counts, "E1": e1(H, L), "E2": e2(H, L), "E3": e3(H, L), "E4": e4(H, L), "dedup": dedup(H)}
(ST / "extension_results.json").write_text(json.dumps(S, indent=1, default=float)); print("written", counts)
if __name__ == "__main__":
main()