Datasets:
Formats:
parquet
Languages:
English
Size:
10K - 100K
Tags:
agriculture
plant-disease
crop-disease
vision-language-model
retrieval-augmented-generation
memory
License:
Download code/experiments/mace_extension/scripts/analyze.py from tirtho149/MACE-Bench: direct link, hf CLI and curl.
- Browser
- Download file 23.8 kB
-
https://huggingface.co/datasets/tirtho149/MACE-Bench/resolve/main/code/experiments/mace_extension/scripts/analyze.py
- Command line
-
hf download hf://datasets/tirtho149/MACE-Bench/code/experiments/mace_extension/scripts/analyze.py
-
curl -L -o analyze.py https://huggingface.co/datasets/tirtho149/MACE-Bench/resolve/main/code/experiments/mace_extension/scripts/analyze.py
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() | |