Datasets:
Formats:
parquet
Languages:
English
Size:
10K - 100K
Tags:
agriculture
plant-disease
crop-disease
vision-language-model
retrieval-augmented-generation
memory
License:
Download code/mace10/paper.py from tirtho149/MACE-Bench: direct link, hf CLI and curl.
- Browser
- Download file 29.2 kB
-
https://huggingface.co/datasets/tirtho149/MACE-Bench/resolve/main/code/mace10/paper.py
- Command line
-
hf download hf://datasets/tirtho149/MACE-Bench/code/mace10/paper.py
-
curl -L -o paper.py https://huggingface.co/datasets/tirtho149/MACE-Bench/resolve/main/code/mace10/paper.py
29.2 kB
| """Results-first tables for the MACE paper: every traceable measured value is filled in; every other cell is marked. | |
| python -m mace10.paper writes <paper>/tables/t{1..4}_*.tex, <paper>/numbers_mace10.tex, | |
| mace10/out/table_cells.csv (cell -> status, n, source) and RESULTS_FIRST_DRAFT.md | |
| Cell status (rendered in the PDF): | |
| value measured on this protocol (source recorded per cell) | |
| NR NEEDS RUN (incremental calls and USD from the dry run listed in the caption and table_specs.yaml) | |
| NA NOT APPLICABLE | |
| pilot panel PILOT / DIFFERENT PROTOCOL (soybean, seed 0, runs 0-4, 5 images per disease and run); never merged | |
| into ten-crop rows | |
| Intervals: 95% bootstrap over unique query images, stratified by crop (2,000 resamples, seed 0); equal-crop means. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| HERE = Path(__file__).resolve().parent; OUT = HERE / "out"; LOCK = HERE / "locked" | |
| PAPER = HERE / "paper_src" # editable multi-file source; mace10/build_submission.py writes the single-file Overleaf paper | |
| PILOT = HERE.parent / "runs" | |
| NR = "\\nr{}"; NA = "\\na{}" | |
| cells: list[dict] = []; mac: dict[str, str] = {} | |
| RNG = np.random.default_rng(0); B = 2000 | |
| def cell(table, row, col, value=None, status="measured", n=None, source=""): | |
| cells.append({"table": table, "row": row, "col": col, "status": status, "value": value, "n": n, "source": source}) | |
| return value if status == "measured" else NR if status == "needs_run" else NA | |
| def eqcrop_ci(df, col): | |
| """Equal-crop mean accuracy (%) and stratified bootstrap 95% CI over unique images.""" | |
| groups = [g[col].to_numpy(float) for _, g in df.groupby("crop")] | |
| est = np.mean([g.mean() for g in groups]) * 100 | |
| bs = [np.mean([RNG.choice(g, len(g)).mean() for g in groups]) * 100 for _ in range(B)] | |
| return est, np.percentile(bs, 2.5), np.percentile(bs, 97.5) | |
| def fmt(e, lo=None, hi=None): | |
| return f"{e:.1f}" if lo is None else f"{e:.1f} {{\\tiny[{lo:.1f}, {hi:.1f}]}}" | |
| RES: dict = {} | |
| def minus(t): | |
| """True minus signs for negative numbers in generated text.""" | |
| import re | |
| return re.sub(r"(?<![\w.])-(?=\d)", "$-$", t) | |
| METHOD_MACRO = {"sage": "Sage", "majority": "Maj", "wvote": "Vote", "clip_s0": "Clip", "dino_s0": "Dino", "mace": "Mace", "mace_K1": "MaceKone", "mace_K16": "MaceKsixteen", | |
| "labels": "Labels", "labels_all": "LabelsAll", "dino_labels": "DinoLabels", "masked": "Masked", "shuffled": "Shuffled", "random": "Random", "same_source": "SameSrc", "other_source": "OtherSrc", "agentic": "Agentic", "imageref": "ImageRef"} | |
| def acc(panel, sp, m, interval=True, key="acc"): | |
| """Measured value as text, or the NEEDS RUN mark when the package has not produced it.""" | |
| d = RES.get("accuracy", {}).get(panel, {}).get(sp, {}).get(m) | |
| if d is None: | |
| return NR | |
| return fmt(d[key], *d["ci"]) if interval and key == "acc" else fmt(d[key]) | |
| def macros_from_results(): | |
| for panel, tag in (("hero", "Hero"), ("ablation", "Abl"), ("efficiency", "Eff"), ("source", "Src")): | |
| for sp, d in RES["accuracy"][panel].items(): | |
| for m, v in d.items(): | |
| if m in METHOD_MACRO: | |
| mac[f"tc{tag}{METHOD_MACRO[m]}{sp.upper()}"] = f"{v['acc']:.1f}" | |
| words = {"mace_minus_sage": "MaceSage", "mace_minus_dino": "MaceDino", "labels_minus_mace": "LabelsMace", "masked_minus_labels": "MaskedLabels", "mace_minus_masked": "MaceMasked", | |
| "mace_minus_shuffled": "MaceShuffled", "mace_minus_random": "MaceRandom", "same_minus_other": "SameOther", "imageref_minus_mace": "ImageRefMace", "agentic_minus_mace": "AgenticMace"} | |
| for k, v in RES["contrasts"].items(): | |
| name, sp = k.rsplit("_", 1); w = "tcD" + words[name] + sp.upper() | |
| mac[w] = f"{v['est']:+.1f}"; mac[w + "lo"] = f"{v['ci'][0]:+.1f}"; mac[w + "hi"] = f"{v['ci'][1]:+.1f}" | |
| if "p_holm" in v: | |
| mac[w + "p"] = "<0.001" if v["p_holm"] < 0.001 else f"{v['p_holm']:.3f}" | |
| for k, v in RES.get("amendment", {}).items(): | |
| if k == "hit_rates": | |
| for sp, h in v.items(): | |
| mac[f"tcHitBm{sp.upper()}"] = f"{h['bm25']:.1f}"; mac[f"tcHitDino{sp.upper()}"] = f"{h['dino']:.1f}" | |
| continue | |
| name, sp = k.rsplit("_", 1); w = "tcA" + {"labels_all_minus_mace": "LabelsMace", "dino_labels_minus_labels_all": "DinoBm", "dino_labels_minus_dino": "DinoNN"}[name] + sp.upper() | |
| mac[w] = f"{v['est']:+.1f}"; mac[w + "lo"] = f"{v['ci'][0]:+.1f}"; mac[w + "hi"] = f"{v['ci'][1]:+.1f}" | |
| W = pd.read_csv(OUT / "results_wide.csv"); H = W[W.hero]; g = H.groupby(["crop", "split"])[["mace", "sage", "hit"]].mean().mul(100); g["gain"] = g.mace - g.sage | |
| mac["tcHitR"] = f"{np.corrcoef(g.hit, g.gain)[0, 1]:.2f}"; pot = g.loc[("Potato", "ood")]; mac["tcPotatoHit"] = f"{pot.hit:.1f}"; mac["tcPotatoLoss"] = f"{-pot.gain:.1f}" | |
| Lb = pd.read_csv(OUT / "local_baselines.csv"); Lb = Lb[(Lb.panel == "hero") & (Lb.seed == 0) & (Lb.K == 4)].groupby("crop").bank_size.mean() | |
| mac["tcBankMean"] = f"{Lb.mean():.0f}"; mac["tcBankMin"] = f"{Lb.min():.0f}"; mac["tcBankMax"] = f"{Lb.max():.0f}"; mac["tcBankUsd"] = f"{Lb.mean() * 0.0043:.2f}" # 0.0043: measured USD per caption | |
| for m, v in RES["efficiency"]["methods"].items(): | |
| mac[f"tcEff{METHOD_MACRO[m]}PerCorrect"] = f"{v['usd'] / (v['acc_all'] / 100):.3f}" | |
| P1 = pd.DataFrame(map(json.loads, (OUT / "P1/predictions.jsonl").open())); Mq = P1[P1.condition == "mace"].copy(); Mq["sage"] = Mq.image_id.map(P1[P1.condition == "sage"].set_index("image_id").correct).astype(bool); Mq["correct"] = Mq.correct.astype(bool) | |
| Mq["nt"] = [sum(l == r.label for l in r.memory_labels_shown) for r in Mq.itertuples()] | |
| for sp, S_ in (("iid", "IID"), ("ood", "OOD")): | |
| g_ = Mq[Mq.split == sp]; mac[f"tcFix{S_}"] = f"{100 * (g_.correct & ~g_.sage).mean():.1f}"; mac[f"tcBreak{S_}"] = f"{100 * (~g_.correct & g_.sage).mean():.1f}" | |
| mac[f"tcDoseNone{S_}"] = f"{100 * g_[g_.nt == 0].correct.mean():.0f}"; mac[f"tcDoseAll{S_}"] = f"{100 * g_[g_.nt == 4].correct.mean():.0f}"; mac[f"tcDoseAllN{S_}"] = f"{(g_.nt == 4).sum()}" | |
| E = RES["efficiency"]["methods"]; mac["tcEffGainPts"] = f"{E['mace']['acc_all'] - E['sage']['acc_all']:.1f}"; mac["tcEffGainUsd"] = f"{E['mace']['usd'] - E['sage']['usd']:.4f}" | |
| for sp, S in (("iid", "IID"), ("ood", "OOD")): | |
| h = RES["hit_miss"][sp]; ab = RES["accuracy"]["ablation"][sp] | |
| mac[f"tcHitGain{S}"] = f"{h['hit']['mace'] - h['hit']['sage']:.1f}"; mac[f"tcMissLoss{S}"] = f"{h['miss']['sage'] - h['miss']['mace']:.1f}" | |
| mac[f"tcLabelsVote{S}"] = f"{ab['labels']['acc'] - ab['majority']['acc']:.1f}" | |
| mac[f"tcCapGain{S}"] = f"{-RES['amendment'][f'labels_all_minus_mace_{sp}']['est']:.1f}" | |
| for sp, v in RES["hit_miss"].items(): | |
| S = sp.upper(); mac[f"tcHitRate{S}"] = f"{v['hit_rate']:.1f}" | |
| for nm in ("hit", "miss"): | |
| mac[f"tc{nm.title()}Mace{S}"] = f"{v[nm]['mace']:.1f}"; mac[f"tc{nm.title()}Sage{S}"] = f"{v[nm]['sage']:.1f}"; mac[f"tc{nm.title()}N{S}"] = f"{v[nm]['n']}" | |
| for sp, v in RES["selection"].items(): | |
| S = sp.upper() | |
| for m in ("mace", "clip", "dino"): | |
| mac[f"tcSD{m.title()}{S}"] = f"{v[m]['sd']:.1f}" | |
| for k, w in (("mean_minus_sage", "Sage"), ("mean_minus_dino", "Dino")): | |
| mac[f"tcMean{w}{S}"] = f"{v[k]['est']:+.1f}" | |
| for m, v in RES["efficiency"]["methods"].items(): | |
| w = METHOD_MACRO[m]; mac[f"tcEff{w}Acc"] = f"{v['acc_all']:.1f}"; mac[f"tcEff{w}Usd"] = f"{v['usd']:.3f}"; mac[f"tcEff{w}Sec"] = f"{v['latency_s']:.0f}"; mac[f"tcEff{w}Comp"] = f"{v['completion']:.1f}" | |
| def dry(): | |
| D = pd.read_csv(OUT / "dryrun_packages.csv"); S = json.loads((OUT / "dryrun.json").read_text()) | |
| return D, S | |
| def usd(D, pkg, cond=None): | |
| d = D[(D.package == pkg) & ((D.condition == cond) if cond else True)] | |
| return d.new_calls.sum(), d.projected_usd.sum() | |
| def pilot(): | |
| P = pd.DataFrame(map(json.loads, (PILOT / "soybean_seed0_n5_pilot/predictions.jsonl").open())) | |
| G = pd.DataFrame(map(json.loads, (PILOT / "soybean_seed0_n5_pilot_agentic/predictions.jsonl").open())) | |
| bad = (G.caption_reads == 0) & (G.num_turns == 1) & (G.prediction == "UNKNOWN"); G = G[~bad] | |
| return P, G | |
| def t1(L, D): | |
| """Ten-crop hero. Panel A: equal-crop means per method. Panel B: per crop. Panel C: soybean pilot.""" | |
| h = L[(L.panel == "hero") & L.hero & (L.seed == 0) & (L.K == 4)] | |
| rowsA = [] | |
| calls, cost = usd(D, "P1") | |
| for name, m in (("SAGE (KB only)", "sage"), ("Retrieved-label majority", "majority"), ("Score-weighted label vote", "wvote"), | |
| ("OpenCLIP 1-NN", "clip_s0"), ("DINOv2 1-NN", "dino_s0"), ("Labels only$^\\dagger$", "labels_all"), ("DINOv2-retrieved labels$^\\dagger$", "dino_labels"), | |
| ("MACE retrieval ($K{=}4$)", "mace")): | |
| out = [name] | |
| for sp in ("iid", "ood"): | |
| v = acc("hero", sp, m); out.append(cell("T1", name, sp, v, status="needs_run" if v == NR else "measured", n=int((h.split == sp).sum()), source="mace10/out/results.json")) | |
| for sp in ("iid", "ood"): | |
| v = acc("hero", sp, m, key="macro"); out.append(cell("T1", name, f"macro_{sp}", v, status="needs_run" if v == NR else "measured", source="mace10/out/results.json")) | |
| rowsA.append(out) | |
| if m in ("clip_s0", "dino_s0"): | |
| for sp in ("iid", "ood"): | |
| mac[f"hero{'Clip' if 'clip' in m else 'Dino'}{sp.upper()}"] = f"{RES['accuracy']['hero'][sp][m]['acc']:.1f}" | |
| rowsB = [] | |
| for crop, g in h.groupby("crop", sort=False): | |
| r = [crop] | |
| for sp in ("iid", "ood"): | |
| gg = g[g.split == sp]; c = RES.get("per_crop", {}).get(crop, {}).get(sp) | |
| r += [str(len(gg)), f"{c['sage']:.1f}", f"{100 * gg.dino_correct.mean():.1f}", f"{c['mace']:.1f}", f"{c['mace'] - c['sage']:+.1f}"] if c else [str(len(gg)), NR, f"{100 * gg.dino_correct.mean():.1f}", NR, NR] | |
| rowsB.append(r) | |
| # pilot panel | |
| P, G = pilot(); sage = P[P.condition == "sage"].set_index("image_id").correct | |
| R = P[P.condition == "agmem"]; Lp = L[L.panel == "pilot"] | |
| pv = [] | |
| for sp, spp in (("iid", "test_iid"), ("ood", "test_ood_in_scope")): | |
| r4 = R[(R.K == 4) & (R.split == spp)]; lp = Lp[(Lp.K == 4) & (Lp.split == sp)] | |
| maj = np.mean([bool(s) and pd.Series(s).value_counts().index[0] == l for l, s in zip(r4.label, r4.memory_labels_shown)]) * 100 | |
| def wvote(labs, rel): | |
| sc = {} | |
| for l_, w in zip(labs or [], rel or []): | |
| sc[l_] = sc.get(l_, 0) + w | |
| return max(sorted(sc), key=lambda k: sc[k]) if sc else None | |
| wv = np.mean([wvote(s_, w_) == l for l, s_, w_ in zip(r4.label, r4.memory_labels_shown, r4.memory_relevance)]) * 100 | |
| pv.append((100 * r4.image_id.map(sage).mean(), maj, 100 * lp.clip_correct.mean(), 100 * lp.dino_correct.mean(), 100 * r4.correct.mean(), len(r4), wv)) | |
| mac[f"pilotDino{sp.upper()}"] = f"{100 * lp.dino_correct.mean():.1f}" | |
| pilot_cols = {"SAGE (KB only)": 0, "Retrieved-label majority": 1, "Score-weighted label vote": 6, "OpenCLIP 1-NN": 2, "DINOv2 1-NN": 3, "MACE retrieval ($K{=}4$)": 4} | |
| for r in rowsA: | |
| i = pilot_cols.get(r[0]) | |
| r += [""] + ([f"{pv[0][i]:.1f}", f"{pv[1][i]:.1f}"] if i is not None else ["--", "--"]) | |
| body = "\n".join(" & ".join(r) + " \\\\" for r in rowsA) | |
| crop_lines = "\n".join(" & ".join(r) + " \\\\" for r in rowsB) | |
| n1, c1 = calls, cost | |
| tex = rf"""\begin{{table*}}[t] | |
| \centering\scriptsize\setlength{{\tabcolsep}}{{5pt}} | |
| \caption{{\textbf{{Ten-crop results}} (primary memory selection: $K{{=}}4$ images per disease, four retrieved captions). Accuracy (\%), equal-crop mean over 10 crops ({int((h.split == 'iid').sum()):,} IID and {int((h.split == 'ood').sum()):,} held-out-collection queries) with a 95\% bootstrap interval over unique images, stratified by crop; macro: mean per-disease recall. Label votes and 1-NN use the exact memory bank MACE sees and call no model. $^\dagger$Post hoc, added after the 400-query labels-only control was read. Right: the earlier soybean pilot under a different protocol (5 runs, 5 images per disease and run; {pv[0][5]} IID and {pv[1][5]} held-out item-runs), not pooled with the ten-crop columns.}} | |
| \label{{tab:hero}} | |
| \begin{{tabular}}{{lccccc@{{\hspace{{10pt}}}}cc}} | |
| \toprule | |
| & \multicolumn{{4}}{{c}}{{Ten crops}} & & \multicolumn{{2}}{{c}}{{\pilottag{{}} soybean, different protocol}} \\ | |
| \cmidrule(lr){{2-5}}\cmidrule(lr){{7-8}} | |
| Method & IID & Held-out & Macro IID & Macro held-out & & IID & Held-out \\ | |
| \midrule | |
| {body.replace(" \\\\", " \\\\").replace(" & ", " & ", 0)} | |
| \bottomrule | |
| \end{{tabular}} | |
| \end{{table*}} | |
| """ | |
| (PAPER / "tables/t1_hero.tex").write_text(tex) | |
| crop_tex = ("% Panel B (per crop) for the supporting results\n\\begin{tabular}{lcccccccccc}\n\\toprule\n & \\multicolumn{5}{c}{IID} & \\multicolumn{5}{c}{Held-out}\\\\\n" | |
| "Crop & $n$ & SAGE & DINOv2 & MACE & $\\Delta$ & $n$ & SAGE & DINOv2 & MACE & $\\Delta$ \\\\\n\\midrule\n" + crop_lines + "\n\\bottomrule\n\\end{tabular}\n") | |
| (PAPER / "tables/t1b_per_crop.tex").write_text(crop_tex) | |
| def macro_recall(df, key): | |
| return 100 * df.groupby("label")[key].mean().mean() | |
| CONTROLS = [("MACE (captions + labels)", "mace"), ("Labels only", "labels"), ("Captions only (masked)", "masked"), ("Shuffled labels", "shuffled"), ("Random references", "random")] | |
| def delta(m): | |
| """Difference from MACE on the ablation panel, IID / held-out.""" | |
| A = RES.get("accuracy", {}).get("ablation", {}) | |
| if m == "mace" or m not in A.get("iid", {}): | |
| return "--" | |
| return " / ".join(f"{A[sp][m]['acc'] - A[sp]['mace']['acc']:+.1f}" for sp in ("iid", "ood")) | |
| def t2(L, D): | |
| a = L[(L.panel == "hero") & L.ablation & (L.seed == 0)] | |
| c3, u3 = usd(D, "P3"); c4, u4 = usd(D, "P4") | |
| rows = [] | |
| for K in (1, 4, 16): | |
| r = [f"$K{{=}}{K}$"] | |
| mk = "mace" if K == 4 else f"mace_K{K}" | |
| r.append(f"{acc('ablation', 'iid', mk, False)} / {acc('ablation', 'ood', mk, False)}") | |
| for sp in ("iid", "ood"): | |
| g = a[(a.K == K) & (a.split == sp)]; e, lo, hi = eqcrop_ci(g, "dino_correct") | |
| r.append(fmt(e)); mac[f"ablDinoK{ {1: 'one', 4: 'four', 16: 'sixteen'}[K]}{sp.upper()}"] = f"{e:.1f}" | |
| rows.append(r) | |
| P, G = pilot(); R = P[P.condition == "agmem"]; sage = P[P.condition == "sage"].set_index("image_id").correct | |
| pil = [] | |
| for K in (1, 4, 16): | |
| v = [100 * R[(R.K == K) & (R.split == s)].correct.mean() for s in ("test_iid", "test_ood_in_scope")] | |
| pil.append(f"$K{{=}}{K}$ & {v[0]:.1f} / {v[1]:.1f} & & \\\\") | |
| body_a = "\n".join(f"{r[0]} & {r[1]} & {r[2]} & {r[3]} \\\\" for r in rows) | |
| body_b = "\n".join(f"{n_} & {acc('ablation', 'iid', m_, False)} & {acc('ablation', 'ood', m_, False)} & {delta(m_)} \\\\" for n_, m_ in CONTROLS) | |
| tex = rf"""\begin{{table}}[t] | |
| \centering\scriptsize\setlength{{\tabcolsep}}{{3pt}} | |
| \caption{{\textbf{{What the gain is made of}} (400 nested queries, 40 per crop, 20 IID + 20 held-out, seed 0). Accuracy (\%), equal-crop mean. A: memory size, nested banks, always four retrieved captions; DINOv2 1-NN on the same banks for reference (measured, no model call). B: content controls at $K{{=}}4$ with identical queries, KB claims and candidates. $K{{=}}16$ banks hold fewer than 16 images for diseases with few training images.}} | |
| \label{{tab:ablation}} | |
| \begin{{tabular}}{{lccc}} | |
| \toprule | |
| \multicolumn{{4}}{{l}}{{\textit{{A. Memory size}}}} \\ | |
| Bank & MACE (IID / held-out) & DINOv2 IID & DINOv2 held-out \\ | |
| \midrule | |
| {body_a} | |
| \midrule | |
| \multicolumn{{4}}{{l}}{{\textit{{B. Content controls, $K{{=}}4$}}}} \\ | |
| Evidence shown & IID & Held-out & $\Delta$ vs MACE \\ | |
| \midrule | |
| {body_b} | |
| \midrule | |
| \multicolumn{{4}}{{l}}{{\textit{{\pilottag{{}} Soybean, different protocol: MACE (IID / held-out)}}}} \\ | |
| {chr(10).join(pil)} | |
| \bottomrule | |
| \end{{tabular}} | |
| \end{{table}} | |
| """ | |
| (PAPER / "tables/t2_ablation.tex").write_text(tex) | |
| def t3(L, D): | |
| h = L[(L.panel == "hero") & L.hero & (L.K == 4)] | |
| c2, u2 = usd(D, "P2"); c5, u5 = usd(D, "P5") | |
| lines = [] | |
| for name, key in (("MACE retrieval", None), ("OpenCLIP 1-NN", "clip_correct"), ("DINOv2 1-NN", "dino_correct")): | |
| r = [name]; vals = {"iid": [], "ood": []} | |
| for s in (0, 1, 2): | |
| for sp in ("iid", "ood"): | |
| if key: | |
| e, _, _ = eqcrop_ci(h[(h.seed == s) & (h.split == sp)], key); vals[sp].append(e); r.append(f"{e:.1f}") | |
| else: | |
| r.append(acc("hero", sp, "mace" if s == 0 else f"mace_s{s}", False)) | |
| for sp in ("iid", "ood"): | |
| sel = RES.get("selection", {}).get(sp) | |
| r.append(f"{np.std(vals[sp], ddof=1):.1f}" if key else f"{sel['mace']['sd']:.1f}" if sel else NR) | |
| lines.append(" & ".join(r) + " \\\\") | |
| if key: | |
| mac[f"rel{'Clip' if 'clip' in key else 'Dino'}SD"] = f"{np.std(vals['iid'], ddof=1):.1f}" | |
| # pilot hit/miss (measured, different protocol) | |
| P, G = pilot(); sage = P[P.condition == "sage"].set_index("image_id").correct | |
| R = P[(P.condition == "agmem") & (P.K == 4)].copy(); R["hit"] = [l in (s or []) for l, s in zip(R.label, R.memory_labels_shown)] | |
| R["sage"] = R.image_id.map(sage).astype(bool) | |
| pl = [] | |
| for sp, nm in (("test_iid", "IID"), ("test_ood_in_scope", "Held-out")): | |
| g = R[R.split == sp]; hh, mm = g[g.hit], g[~g.hit] | |
| pl.append(f"{nm} & {100 * g.hit.mean():.1f} & {100 * hh.correct.mean():.1f} / {100 * hh.sage.mean():.1f} & {100 * mm.correct.mean():.1f} / {100 * mm.sage.mean():.1f} \\\\") | |
| hm = [f"Ten crops, {nm} & {v['hit_rate']:.1f} & {v['hit']['mace']:.1f} / {v['hit']['sage']:.1f} & {v['miss']['mace']:.1f} / {v['miss']['sage']:.1f} \\\\" for nm, v in | |
| (("IID", RES["hit_miss"].get("iid")), ("held-out", RES["hit_miss"].get("ood"))) if v] | |
| srcn = RES.get("accuracy", {}).get("source", {}).get("iid", {}).get("sage", {}).get("n", "--") | |
| tex = rf"""\begin{{table}}[t] | |
| \centering\scriptsize\setlength{{\tabcolsep}}{{2.6pt}} | |
| \caption{{\textbf{{Reliability.}} A: accuracy (\%, equal-crop mean, 1,600 queries) under three locked memory selections (release seeds 0--2; each query keeps its fold eligibility); SD across selections is memory-selection sensitivity, not an image-sampling interval. B: hit = true disease among the four retrieved captions; MACE / SAGE accuracy on identical hit and miss items; associative, and hit status is oracle information. C: same- vs other-source memory on {srcn} paired IID queries.}} | |
| \label{{tab:reliability}} | |
| \begin{{tabular}}{{lcccccccc}} | |
| \toprule | |
| \multicolumn{{9}}{{l}}{{\textit{{A. Memory selection (IID, held-out per selection)}}}} \\ | |
| & \multicolumn{{2}}{{c}}{{Seed 0}} & \multicolumn{{2}}{{c}}{{Seed 1}} & \multicolumn{{2}}{{c}}{{Seed 2}} & \multicolumn{{2}}{{c}}{{SD}} \\ | |
| Method & IID & H-o & IID & H-o & IID & H-o & IID & H-o \\ | |
| \midrule | |
| {chr(10).join(lines)} | |
| \midrule | |
| \multicolumn{{9}}{{l}}{{\textit{{B. Retrieval hit and miss: ten crops; \pilottag{{}} soybean, different protocol, $K{{=}}4$}}}} \\ | |
| Set & Hit & \multicolumn{{3}}{{c}}{{MACE / SAGE on hits}} & \multicolumn{{4}}{{c}}{{MACE / SAGE on misses}} \\ | |
| \midrule | |
| {chr(10).join(_hm_rows(hm + pl))} | |
| \midrule | |
| \multicolumn{{9}}{{l}}{{\textit{{C. Same- vs other-source memory (IID): same {acc('source', 'iid', 'same_source', False)}, other {acc('source', 'iid', 'other_source', False)}}}}} \\ | |
| \bottomrule | |
| \end{{tabular}} | |
| \end{{table}} | |
| """ | |
| (PAPER / "tables/t3_reliability.tex").write_text(tex) | |
| def _hm_rows(pl): | |
| out = [] | |
| for l in pl: | |
| a, b, c, d = [x.strip() for x in l.rstrip(" \\").split("&")] | |
| out.append(f"{a} & {b} & \\multicolumn{{3}}{{c}}{{{c}}} & \\multicolumn{{4}}{{c}}{{{d}}} \\\\") | |
| return out | |
| def t4(D): | |
| c6, u6 = usd(D, "P6"); c7, u7 = usd(D, "P7") | |
| P, G = pilot() | |
| led = [json.loads(l) for l in (PILOT / "cost_ledger.jsonl").open()] | |
| el = lambda st: np.median([r["elapsed_s"] for r in led if r.get("stage") == st and not r["cache_hit"] and r.get("elapsed_s")]) | |
| cost = lambda st: np.mean([r["cost_usd"] for r in led if r.get("stage") == st and not r["cache_hit"]]) | |
| cap = cost("caption") | |
| sage = P[P.condition == "sage"].set_index("image_id").correct | |
| R4 = P[(P.condition == "agmem") & (P.K == 4)]; G4 = G[G.K == 4] | |
| pil = [("SAGE (KB only)", 100 * R4.image_id.map(sage).mean(), "100", el("diag:sage"), cost("diag:sage")), | |
| ("MACE retrieval", 100 * R4.correct.mean(), "100", el("diag:agmem") + el("caption"), cost("diag:agmem") + cap), | |
| ("MACE agentic", 100 * G4.correct.mean(), f"{100 * (G4.prediction != 'UNKNOWN').mean():.1f}", np.median(G4.elapsed_s.dropna()) if "elapsed_s" in G4 else el("diag:agentic"), cost("diag:agentic") + cap)] | |
| Em = RES.get("efficiency", {}).get("methods", {}) | |
| rows = "\n".join((f"{n} & {Em[m]['acc_all']:.1f} & {Em[m]['completion']:.1f} & {Em[m]['latency_s']:.0f} & {Em[m]['usd']:.3f} \\\\" if m in Em else f"{n} & {NR} & {NR} & {NR} & {NR} \\\\") | |
| for n, m in (("SAGE (KB only)", "sage"), ("Labels only", "labels"), ("MACE retrieval", "mace"), ("MACE agentic", "agentic"), ("Image references", "imageref"))) | |
| prow = "\n".join(f"{n} & {a:.1f} & {c} & {l:.0f} & {u:.3f} \\\\" for n, a, c, l, u in pil) | |
| tex = rf"""\begin{{table}}[t] | |
| \centering\scriptsize\setlength{{\tabcolsep}}{{3.5pt}} | |
| \caption{{\textbf{{Accuracy against evidence-access effort}} (200 matched queries, 5 crops, 20 IID + 20 held-out each). Accuracy counts failures as wrong; completion = parseable answer; latency = median wall-clock seconds per query; USD = list-price estimate per query including the test caption. Agentic: four reads, at most six turns. Image references: the same four retrieved items shown as images. \pilottag{{}} rows: soybean pilot, different protocol (agentic without a turn bound).}} | |
| \label{{tab:efficiency}} | |
| \begin{{tabular}}{{lcccc}} | |
| \toprule | |
| Method & Acc. & Compl.\ (\%) & Latency (s) & USD \\ | |
| \midrule | |
| {rows} | |
| \midrule | |
| \multicolumn{{5}}{{l}}{{\textit{{\pilottag{{}} Soybean, different protocol (IID and held-out pooled, $K{{=}}4$)}}}} \\ | |
| {prow} | |
| \bottomrule | |
| \end{{tabular}} | |
| \end{{table}} | |
| """ | |
| (PAPER / "tables/t4_efficiency.tex").write_text(tex) | |
| def t2c(D): | |
| """Q2 content controls (all pending) and the matched-efficiency package, in one compact table.""" | |
| c3, u3 = usd(D, "P3"); c4, u4 = usd(D, "P4"); c6, u6 = usd(D, "P6"); c7, u7 = usd(D, "P7") | |
| tests = {"mace": "reference", "labels": "lookup alone", "masked": "descriptions", "shuffled": "label following", "random": "retrieval"} | |
| body = "\n".join(f"{n_} & {acc('ablation', 'iid', m_)} & {acc('ablation', 'ood', m_)} & {tests[m_]} \\\\" for n_, m_ in CONTROLS) | |
| tex = rf"""\begin{{table}}[t] | |
| \centering\scriptsize\setlength{{\tabcolsep}}{{3pt}} | |
| \caption{{\textbf{{Content controls}} at $K{{=}}4$ on the 400-query ablation panel (40 per crop, 20 IID + 20 held-out, nested in Table~\ref{{tab:hero}}): identical queries, KB claims, candidates and retrieved items; only the memory text differs. Accuracy (\%), equal-crop mean, with a 95\% bootstrap interval.}} | |
| \label{{tab:controls}} | |
| \begin{{tabular}}{{lccl}} | |
| \toprule | |
| Evidence shown & IID & Held-out & Tests \\ | |
| \midrule | |
| {body} | |
| \bottomrule | |
| \end{{tabular}} | |
| \end{{table}} | |
| """ | |
| (PAPER / "tables/t2_controls.tex").write_text(tex) | |
| mac["costPsix"] = f"{u6:.0f}"; mac["callsPsix"] = f"{c6:,}"; mac["costPseven"] = f"{u7:.0f}"; mac["callsPseven"] = f"{c7:,}" | |
| c2, u2 = usd(D, "P2"); mac["costPtwo"] = f"{u2:.0f}"; mac["callsPtwo"] = f"{c2:,}" | |
| c1, u1 = usd(D, "P1"); mac["costPone"] = f"{u1:.0f}"; mac["callsPone"] = f"{c1:,}" | |
| def t_main(): | |
| """Table 1: grouped hero results; the best locked cell per column is green; post hoc arms sit in their own block.""" | |
| A = RES["accuracy"]["hero"] | |
| groups = [("No model call", [("Label majority vote", "majority"), ("Score-weighted vote", "wvote"), ("OpenCLIP 1-NN", "clip_s0"), ("DINOv2 1-NN", "dino_s0")]), | |
| ("Frozen VLM: Sonnet 5.5", [("SAGE (KB only)", "sage"), (r"\macelogo\ MACE retrieval", "mace")])] | |
| locked = [m for _, g in groups for _, m in g] | |
| best = {(sp, k): max(locked, key=lambda m: A[sp][m][k]) for sp in ("iid", "ood") for k in ("acc", "macro")} | |
| def c(sp, m, k): | |
| v = A[sp][m]; t = fmt(v["acc"], *v["ci"]) if k == "acc" else fmt(v[k]) | |
| return ("\\cellcolor{bestgreen}" + t) if best.get((sp, k)) == m else t | |
| def row(n, m): | |
| return f"{n} & {c('iid', m, 'acc')} & {c('ood', m, 'acc')} & {c('iid', m, 'macro')} & {c('ood', m, 'macro')} \\\\" | |
| body = [] | |
| for g, rows in groups: | |
| body += [f"\\multicolumn{{5}}{{l}}{{\\textit{{{g}}}}} \\\\"] + [row(n, m) for n, m in rows] + ["\\midrule"] | |
| body += ["\\multicolumn{5}{l}{\\textit{Post hoc tests, Sonnet 5.5}} \\\\", row("Labels only", "labels_all"), "\\midrule"] | |
| hk = json.loads((OUT.parent.parent / "experiments/mace_extension/statistics/extension_results.json").read_text())["E1"]["accuracy"] | |
| body += ["\\multicolumn{5}{l}{\\textit{Post hoc tests, Haiku 5.5}} \\\\"] + [f"{n} & {fmt(hk['iid']['Haiku'][m]['acc'], *hk['iid']['Haiku'][m]['ci'])} & {fmt(hk['ood']['Haiku'][m]['acc'], *hk['ood']['Haiku'][m]['ci'])} & -- & -- \\\\" for n, m in (("SAGE (KB only)", "h_sage"), ("Labels only", "h_labels"), ("MACE retrieval", "h_mace"))] | |
| n1, n2 = A["iid"]["mace"]["n"], A["ood"]["mace"]["n"] | |
| tex = "\n".join([r"\begin{table}[t]", r"\centering\scriptsize\setlength{\tabcolsep}{2.4pt}", | |
| r"\caption{\textbf{Ten-crop results} ($K{=}4$): accuracy (\%), 95\% intervals. Green: best planned method.}", | |
| r"\label{tab:hero}", r"\begin{tabular}{lcccc}", r"\toprule", r"Method & IID & Held-out & Macro IID & Macro H-o \\", r"\midrule", *body, r"\bottomrule", r"\end{tabular}", r"\end{table}", ""]) | |
| (PAPER / "tables/t_main.tex").write_text(minus(tex)) | |
| def t_info(): | |
| """Table 2: caption-versus-label evidence. A: locked matched cohort. B: expanded post hoc panel.""" | |
| A = RES["accuracy"]["ablation"]; H = RES["accuracy"]["hero"]; C = RES["amendment"] | |
| f = lambda d, m: fmt(d[m]["acc"], *d[m]["ci"]) | |
| ci = lambda k: f"{C[k]['est']:+.1f} {{\\tiny[{C[k]['ci'][0]:+.1f}, {C[k]['ci'][1]:+.1f}]}}" | |
| best = {sp: max(("sage", "mace", "labels", "masked", "shuffled", "random"), key=lambda m: A[sp][m]["acc"]) for sp in ("iid", "ood")} | |
| g = lambda sp, m: ("\\cellcolor{bestgreen}" if best[sp] == m else "") + f(A[sp], m) | |
| d = lambda m: "--" if m == "mace" else " / ".join(f"{A[sp][m]['acc'] - A[sp]['mace']['acc']:+.1f}" for sp in ("iid", "ood")) | |
| rowsA = [("SAGE (no memory)", "sage"), ("MACE (captions + labels)", "mace"), ("Labels only", "labels"), ("Captions only (masked)", "masked"), ("Random references", "random"), ("Shuffled labels", "shuffled")] | |
| a = [f"{n} & {g('iid', m)} & {g('ood', m)} & {d(m)} \\\\" for n, m in rowsA] | |
| b = [f"MACE (captions + labels) & {f(H['iid'], 'mace')} & {f(H['ood'], 'mace')} & -- \\\\", | |
| f"Labels only & {f(H['iid'], 'labels_all')} & {f(H['ood'], 'labels_all')} & {C['labels_all_minus_mace_iid']['est']:+.1f} / {C['labels_all_minus_mace_ood']['est']:+.1f} \\\\", | |
| f"DINOv2-retrieved labels & {f(H['iid'], 'dino_labels')} & {f(H['ood'], 'dino_labels')} & {H['iid']['dino_labels']['acc'] - H['iid']['mace']['acc']:+.1f} / {H['ood']['dino_labels']['acc'] - H['ood']['mace']['acc']:+.1f} \\\\", | |
| f"\\textit{{Labels $-$ MACE}} & {ci('labels_all_minus_mace_iid')} & {ci('labels_all_minus_mace_ood')} & Text adds / unclear \\\\", | |
| f"\\textit{{DINOv2 $-$ BM25 labels}} & {ci('dino_labels_minus_labels_all_iid')} & {ci('dino_labels_minus_labels_all_ood')} & Matched / unclear \\\\"] | |
| tex = "\n".join([r"\begin{table}[t]", r"\centering\scriptsize\setlength{\tabcolsep}{1.9pt}", | |
| r"\caption{\textbf{Post hoc tests}, all 1,600 queries: accuracy (\%), 95\% intervals.}", | |
| r"\label{tab:controls}", r"\begin{tabular}{lccc}", r"\toprule", r"Evidence shown & IID & Held-out & vs MACE \\\\", r"\midrule", *b, r"\bottomrule", r"\end{tabular}", r"\end{table}", ""]) | |
| (PAPER / "tables/t_info.tex").write_text(minus(tex)) | |
| def main(): | |
| D, S = dry(); L = pd.read_csv(OUT / "local_baselines.csv") | |
| RES.update(json.loads((OUT / "results.json").read_text())) | |
| t1(L, D); t2(L, D); t3(L, D); t4(D); t2c(D); t_main(); t_info() | |
| macros_from_results() | |
| mac["dryTotal"] = f"{S['projected_additional_usd']:.0f}"; mac["dryRequired"] = f"{S['projected_required_usd']:.0f}" | |
| mac["dryCapsNew"] = f"{S['captions_new']:,}"; mac["nHero"] = "1,600" | |
| (PAPER / "numbers_mace10.tex").write_text("% generated by code/agmem-bench/mace10/paper.py; do not edit\n" + | |
| "\n".join(f"\\newcommand{{\\{k}}}{{{minus(v) if k.startswith('tc') else v}}}" for k, v in sorted(mac.items())) + "\n") | |
| pd.DataFrame(cells).to_csv(OUT / "table_cells.csv", index=False) | |
| print(json.dumps(mac, indent=0)) | |
| if __name__ == "__main__": | |
| main() | |