File size: 6,142 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
"""Dispatch one extension package. Resumable, cap-checked, one provenance row per job.

  python -m experiments.mace_extension.scripts.run <PKG> [--model ID] [--limit N] [--sample N]
  python -m experiments.mace_extension.scripts.run identity        # zero-cost: Sonnet jobs must all return from cache

Reuses mace10.run for captions, the stop logic and the evidence builders. Captions always run on the frozen caption model.
"""
from __future__ import annotations

import argparse
import hashlib
import json
import random
import subprocess
import threading
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

from agmem import config as C, data, kb as KB, llm, prompts
from mace10 import run as M
from . import jobs as X

ROOT = Path(__file__).resolve().parent.parent
RAW = ROOT / "raw_results"
HARD_STOP = 872.82      # established limit: USD 400 additional beyond ledger 472.82
SOFT_STOP = 822.82      # established limit: no optional work past this ledger total


def manifest_sha() -> str:
    p = data.C.DATA / "LOCK.json"
    return hashlib.sha256(p.read_bytes()).hexdigest() if p.exists() else ""


def tree_state() -> dict:
    g = lambda *a: subprocess.run(["git", *a], cwd=C.ROOT, capture_output=True, text=True).stdout
    return {"git": g("rev-parse", "HEAD").strip(), "dirty_diff_sha": hashlib.sha256(g("diff").encode()).hexdigest()}


def one(model, crop, classes, kbd, caps, j):
    with llm.use_model(model):
        rec = M.diagnose(crop, classes, kbd, caps, j)
    return {**rec, "experiment": j["pkg"], "diagnosis_model": model or C.MODEL, "memory_bank_ids": [m["image_id"] for m in (j["memory"] or [])], "t": time.time()}


def run(pkg, model=None, limit=None, sample=None, tag="", cap=SOFT_STOP):
    name = pkg + (f"_{tag}" if tag else ""); d = RAW / name; d.mkdir(parents=True, exist_ok=True)
    pred, fail = d / "predictions.jsonl", d / "failures.jsonl"
    start = M.spent(); llm.set_budget(cap)
    J = X.build(pkg); total = len(J)
    if sample:
        J = random.Random(0).sample(J, sample)
    if limit:
        J = J[:limit]
    seen = {json.loads(l)["job_id"] for l in pred.open()} if pred.exists() else set()
    todo = [j for j in J if j["job_id"] not in seen]
    with (d / "manifest.jsonl").open("a") as f:
        f.write(json.dumps({"pkg": name, "jobs_total": total, "selected": len(J), "done_before": len(seen), "diagnosis_model": model or C.MODEL, "caption_model": C.MODEL,
                            "ledger_start": start, "cap_ledger": cap, **tree_state(), "data_rev": C.HF_REV, "dataset_lock_sha": manifest_sha(),
                            "diag_system_sha": llm.sha(prompts.DIAG_SYS), "caption_system_sha": llm.sha(prompts.CAPTION_SYS), "claude_cli": subprocess.run(["claude", "--version"], capture_output=True, text=True).stdout.strip(),
                            "parallel": C.PARALLEL, "started": time.time()}) + "\n")
    print(f"{name}: {len(todo)} to do of {total}, ledger {start:.2f}, model {model or C.MODEL}", flush=True)
    caps, cstats, stop = M.captions(todo, fail)
    print(f"captions {cstats['calls']} ({cstats['cache_hits']} cached, {cstats['empty']} empty) ${cstats['usd_micro'] / 1e6:.2f}", flush=True)
    recs = []
    if not stop:
        kbs = {c: (data.classes(c), KB.build(c, data.classes(c))) for c in {j["crop"] for j in todo}}
        with pred.open("a") as fh, ThreadPoolExecutor(C.PARALLEL) as ex:
            def keep(r):
                fh.write(json.dumps(r) + "\n"); fh.flush(); recs.append(r)
                if len(recs) % 200 == 0:
                    print(f"{len(recs)}/{len(todo)} ledger {M.spent():.2f}", flush=True)
            flag = threading.Event()
            futs = {ex.submit(M.guarded, flag, one, model, j["crop"], *kbs[j["crop"]], caps, j): j["job_id"] for j in todo}
            stop = M.drain(futs, flag, keep, fail)
    end = M.spent(); new = [r for r in recs if not r["cache_hit"]]
    st = {"pkg": name, "jobs_total": total, "selected": len(J), "rows": len(seen) + len(recs), "complete": len(seen) + len(recs) == total, "stop": stop, "incurred_usd": round(end - start, 4),
          "ledger_total": round(end, 4), "new_calls": len(new), "cache_hits": len(recs) - len(new), "mean_new_call_usd": round(sum(r["cost_usd"] or 0 for r in new) / max(1, len(new)), 5),
          "unknown_predictions": sum(r.get("prediction") == "UNKNOWN" for r in recs), "model_ids": sorted({m for r in new for m in (r.get("model_ids") or [])}), "finished": time.time()}
    (d / "status.json").write_text(json.dumps(st, indent=1)); print(json.dumps(st, indent=1), flush=True)
    return st, recs


def identity():
    """Rebuild the Sonnet requests through this code path and compare with the saved rows. No new call is allowed."""
    llm.set_budget(M.spent())    # any uncached call would raise BudgetExceeded
    from mace10 import results as R
    old = {}
    for pkg in ("P1", "P4labels", "P8", "P5"):
        D = R.load(pkg)
        for r in D.itertuples():
            old[(r.condition, r.image_id)] = r.prediction
    J = [j for j in X.build("E1_x")] + [j for j in X.build("E4other") if (j["condition"], j["image_id"]) in old]
    J = random.Random(1).sample(J, 400)
    caps = json.loads((M.OUT / "captions.json").read_text()); same = hit = 0
    for j in J:
        c, k = data.classes(j["crop"]), KB.build(j["crop"], data.classes(j["crop"]))
        r = one(None, j["crop"], c, k, caps, j)
        hit += bool(r["cache_hit"]); same += r["prediction"] == old[(j["condition"], j["image_id"])]
    out = {"jobs": len(J), "cache_hits": hit, "same_prediction": same}
    (RAW / "identity_check.json").write_text(json.dumps(out, indent=1)); print(out)


if __name__ == "__main__":
    ap = argparse.ArgumentParser(); ap.add_argument("pkg"); ap.add_argument("--model"); ap.add_argument("--limit", type=int); ap.add_argument("--sample", type=int); ap.add_argument("--tag", default=""); ap.add_argument("--cap", type=float, default=SOFT_STOP)
    a = ap.parse_args()
    if a.pkg == "identity":
        identity()
    else:
        assert a.cap <= HARD_STOP
        run(a.pkg, a.model, a.limit, a.sample, a.tag, a.cap)