Datasets:
Formats:
parquet
Languages:
English
Size:
10K - 100K
Tags:
agriculture
plant-disease
crop-disease
vision-language-model
retrieval-augmented-generation
memory
License:
File size: 10,346 Bytes
c8e03af | 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 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | """Run Ag-MEM and its variants (plus the SAGE KB-only baseline) on one crop of the frozen benchmark.
python -m agmem.run plan --crop Soybean --seed 0 --n 15
python -m agmem.run run --crop Soybean --seed 0 --n 15 --cap 700
Conditions (identical model, system prompt, class list, KB and schema; only the memory differs):
sage KB only, no memory (memory-independent, so each test image is diagnosed once)
agmem KB + 4 captions retrieved from the mixed memory (K per disease, every K in KS)
same_source memory only from the test image's own collection (paired IID items)
other_source memory with the test image's collection removed (paired IID items)
shuffled mixed memory with permuted labels (IID and OOD in-scope items)
Order of execution puts the headline conditions first, so a budget stop never leaves them half done.
"""
from __future__ import annotations
import argparse
import json
import subprocess
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from . import config as C, data, kb as KB, llm, packet, prompts
DIAG_COST, CAPTION_COST = 0.0162, 0.0041 # measured means (USD per call) from earlier soybean runs
AGENTIC_COST = 0.123 # measured mean, 4-image calibration 2026-11-03
def out_dir(crop, seed, n, tag=""):
seeds = "-".join(map(str, seed)) if isinstance(seed, (list, tuple)) else seed
return C.RUNS / f"{data.slug(crop)}_seed{seeds}_n{n or 'all'}{('_' + tag) if tag else ''}"
def build_jobs(crop: str, seed, n: int | None, ks=None, conditions=None, splits=None) -> list[dict]:
"""seed: int or list of ints. ks / conditions / splits restrict the job set (None = all)."""
seeds = list(seed) if isinstance(seed, (list, tuple)) else [seed]
ks = tuple(ks or C.KS); conditions = set(conditions or ("sage", "agmem", "same_source", "other_source", "shuffled"))
jobs = []
for sd in seeds:
jobs += _jobs_one_seed(crop, sd, n, ks, conditions, splits)
# SAGE is memory-independent: keep one job per image across seeds
seen, out = set(), []
for j in jobs:
if j["condition"] == "sage":
if j["image_id"] in seen: continue
seen.add(j["image_id"])
out.append(j)
return out
def _jobs_one_seed(crop, seed, n, ks, conditions, splits):
T = data.test_items(crop, seed, n)
if splits:
T = T[T.split.isin(splits)]
P = data.paired(); P = P[(P.crop == crop) & (P.seed == seed)]
pe = set(zip(P.run, P.image_id))
base = lambda t: {"seed": seed, "run": int(t.run), "image_id": t.image_id, "split": t.split, "label": t.disease, "collection": t.collection}
jobs = [{"condition": "sage", "seed": None, "K": None, "run": None, "image_id": i, "split": None, "label": data.images().loc[i, "class"],
"collection": data.images().loc[i, "collection"], "memory": None} for i in sorted(T.image_id.unique())] if "sage" in conditions else []
mem = lambda df, shown="disease": [{"image_id": r.image_id, "label_shown": getattr(r, shown), "label_true": r.disease} for r in df.itertuples()]
order = {"agmem": [], "agentic": [], "same_source": [], "other_source": [], "shuffled": []}
for K in ks:
for run in sorted(T.run.unique()):
mixed = data.memory_set(crop, seed, run, K)
for t in T[T.run == run].itertuples():
if "agmem" in conditions:
order["agmem"].append({**base(t), "condition": "agmem", "K": K, "memory": mem(mixed)})
if "agentic" in conditions:
order["agentic"].append({**base(t), "condition": "agentic", "K": K, "memory": mem(mixed)})
if t.split == "test_iid" and (run, t.image_id) in pe:
for v in [x for x in ("same_source", "other_source") if x in conditions]:
order[v].append({**base(t), "condition": v, "K": K, "memory": mem(data.memory_set(crop, seed, run, K, v, t.collection))})
if "shuffled" in conditions and t.split in ("test_iid", "test_ood_in_scope"):
order["shuffled"].append({**base(t), "condition": "shuffled", "K": K, "memory": mem(mixed, "shuffled_class")})
for v in order.values():
jobs += v
for j in jobs:
j["job_id"] = f"{j['condition']}|s{j['seed']}|K{j['K']}|r{j['run']}|{j['image_id']}"
return jobs
def caption_jobs(jobs) -> list[str]:
ids = {j["image_id"] for j in jobs}
for j in jobs:
ids |= {m["image_id"] for m in (j["memory"] or [])}
return sorted(ids)
def _cached(system, content) -> bool:
return (C.CACHE / "llm" / f"{llm.sha({'m': C.MODEL, 's': system, 'c': content})}.json").exists()
def plan(crop, seed, n, write=True, ks=None, conditions=None, splits=None, tag=""):
jobs = build_jobs(crop, seed, n, ks, conditions, splits); caps = caption_jobs(jobs)
from collections import Counter
byc = Counter(j["condition"] for j in jobs)
est = len(caps) * CAPTION_COST + sum(AGENTIC_COST if j["condition"] == "agentic" else DIAG_COST for j in jobs)
p = {"crop": crop, "seed": seed, "n_per_disease_per_run": n, "test_rows": sum(1 for j in jobs if j["condition"] == "agmem") // max(1, len(ks or C.KS)),
"conditions": sorted(set(conditions or [])) or "all", "splits": splits or "all",
"distinct_test_images": len({j["image_id"] for j in jobs if j["condition"] == "sage"}), "captions": len(caps),
"diagnoses_by_condition": dict(byc), "diagnoses_total": len(jobs), "Ks": list(ks or C.KS),
"estimate_usd_upper_bound_no_cache": round(est, 2), "data": str(C.DATA), "data_rev": C.HF_REV}
if write:
d = out_dir(crop, seed, n, tag); d.mkdir(parents=True, exist_ok=True); (d / "plan.json").write_text(json.dumps(p, indent=1))
return p, jobs, caps
def _caption(crop, image_id):
r = llm.call(prompts.CAPTION_SYS, [llm.image_block(data.path(image_id)), {"type": "text", "text": prompts.caption_text(crop)}],
stage="caption", tag=image_id)
return image_id, (r["parsed"] if isinstance(r.get("parsed"), dict) else {}), r
def _diagnose(crop, classes, kbd, caps, j):
memory = None
if j["memory"] is not None:
memory = [{"id": "m_" + m["image_id"], "label_shown": m["label_shown"], "label_true": m["label_true"], "caption": caps[m["image_id"]]}
for m in j["memory"]]
text, det = packet.build(crop, kbd, caps[j["image_id"]], memory)
content = [llm.image_block(data.path(j["image_id"])), {"type": "text", "text": prompts.diagnosis_user(crop, classes, text)}]
r = llm.call(prompts.DIAG_SYS, content, stage=f"diag:{j['condition']}", tag=j["job_id"])
pred = prompts.clean_prediction(r.get("parsed"), classes)
return {**{k: v for k, v in j.items() if k != "memory"}, **pred, **det, "memory_pool_size": len(j["memory"] or []),
"correct": pred["prediction"] == j["label"], "cost_usd": 0.0 if r["cache_hit"] else r.get("cost_usd"),
"cache_hit": r["cache_hit"], "model_ids": r.get("model_ids")}
def run(crop, seed, n, cap, ks=None, conditions=None, splits=None, tag=""):
p, jobs, cap_ids = plan(crop, seed, n, True, ks, conditions, splits, tag)
d = out_dir(crop, seed, n, tag); start = llm.spent(); llm.set_budget(start + cap)
git = subprocess.run(["git", "rev-parse", "HEAD"], cwd=C.ROOT, capture_output=True, text=True).stdout.strip()
(d / "manifest.json").write_text(json.dumps({**p, "cap_usd": cap, "ledger_start": start, "git": git, "started": time.time(),
"diag_system_sha": llm.sha(prompts.DIAG_SYS), "caption_system_sha": llm.sha(prompts.CAPTION_SYS)}, indent=1))
print(json.dumps(p, indent=1), flush=True)
classes = data.classes(crop); kbd = KB.build(crop, classes)
(d / "kb_used.json").write_text(json.dumps({c: {"kb_source": v["kb_source"], "n_claims": len(v["claims"])} for c, v in kbd.items()}, indent=1))
caps = {}
with ThreadPoolExecutor(C.PARALLEL) as ex:
for f in as_completed([ex.submit(_caption, crop, i) for i in cap_ids]):
i, c, _ = f.result(); caps[i] = c
(d / "captions.json").write_text(json.dumps(caps))
print(f"captions {len(caps)} spent {llm.spent() - start:.2f}", flush=True)
done = 0; stopped = None
with (d / "predictions.jsonl").open("w") as fh, ThreadPoolExecutor(C.PARALLEL) as ex:
from . import agentic
futs = [ex.submit(agentic.diagnose if j["condition"] == "agentic" else _diagnose, crop, classes, kbd, caps, j) for j in jobs]
for f in as_completed(futs):
try:
rec = f.result()
except llm.BudgetExceeded as e:
stopped = str(e); continue
fh.write(json.dumps(rec) + "\n"); done += 1
if done % 500 == 0:
fh.flush(); print(f"{done}/{len(jobs)} diagnoses spent {llm.spent() - start:.2f}", flush=True)
summary = {"done": done, "jobs": len(jobs), "spent_usd": round(llm.spent() - start, 4), "budget_stop": stopped, "finished": time.time()}
(d / "run_status.json").write_text(json.dumps(summary, indent=1)); print(json.dumps(summary), flush=True)
if __name__ == "__main__":
ap = argparse.ArgumentParser(); ap.add_argument("cmd", choices=["plan", "run"]); ap.add_argument("--crop", required=True)
ap.add_argument("--seed", default="0", help="one seed or a comma list, e.g. 0,1,2"); ap.add_argument("--n", type=int, default=None)
ap.add_argument("--cap", type=float, default=0.0); ap.add_argument("--ks", default=None, help="e.g. 1,4,16")
ap.add_argument("--conditions", default=None, help="e.g. sage,agmem"); ap.add_argument("--splits", default=None, help="e.g. test_iid,test_ood_in_scope")
ap.add_argument("--tag", default="")
a = ap.parse_args()
seed = [int(x) for x in a.seed.split(",")]; seed = seed[0] if len(seed) == 1 else seed
kw = dict(ks=[int(x) for x in a.ks.split(",")] if a.ks else None, conditions=a.conditions.split(",") if a.conditions else None,
splits=a.splits.split(",") if a.splits else None, tag=a.tag)
if a.cmd == "plan":
print(json.dumps(plan(a.crop, seed, a.n, True, **kw)[0], indent=1))
else:
assert a.cap > 0, "--cap is required for a paid run"
run(a.crop, seed, a.n, a.cap, **kw)
|