Make runs resumable: append per generation, skip completed

README.md

@@ -86,3 +86,17 @@ Report four numbers, and never one alone:
 Verified against degenerate strategies: always-VULNERABLE scores 67 percent raw and **50 percent
 balanced**; always-SAFE scores 33 percent raw and **50 percent balanced**. Raw accuracy is printed
 but should never be quoted alone.
+
+## Running it
+
+    python3 guardbench/run.py --tag <name> [--model <path>] [--adapter <path>] [--prompts 1|2|3]
+
+Generations are appended to `results/partial_<tag>.jsonl` as they complete, and a re-run skips
+what is already there. An interrupted run resumes rather than starting over. `--prompts 1` drops
+the brittleness measurement and cuts the run to a third.
+
+To score a partial or finished run without generating anything:
+
+    python3 -c "import json,sys; sys.path.insert(0,'guardbench'); import run; \
+      rows=[json.loads(l) for l in open('guardbench/results/partial_<tag>.jsonl')]; \
+      run.report(rows,'<tag>')"

run.py

@@ -60,30 +60,45 @@ def main():
     a = ap.parse_args()
 
     items = [json.loads(l) for l in open(a.items) if l.strip()]
+    os.makedirs(a.outdir, exist_ok=True)
+    partial = os.path.join(a.outdir, f"partial_{a.tag}.jsonl")
+    done, rows = set(), []
+    if os.path.exists(partial):
+        for line in open(partial):
+            try:
+                r = json.loads(line); done.add((r["id"], r["prompt"])); rows.append(r)
+            except Exception:
+                pass
+        print(f"resuming: {len(rows)} generations already on disk", flush=True)
+    fh = open(partial, "a")
     from mlx_lm import load, stream_generate
     from mlx_lm.sample_utils import make_sampler
     m, tok = load(a.model, adapter_path=a.adapter)
     s = make_sampler(temp=0.0)
 
-    rows = []; t0 = time.time()
+    t0 = time.time()
     total = len(items) * a.prompts
     for i, it in enumerate(items):
         for pi in range(a.prompts):
+            if (it["id"], pi) in done:
+                continue
             g = generate_raw(stream_generate, m, tok,
                 build_chat_prompt(tok, SYS, PROMPTS[pi].format(code=it["code"]), enable_thinking=False),
                 max_tokens=a.max_tokens, sampler=s)
             v, cls = parse(g["raw_output"])
             want = "VULNERABLE" if it["label"] == "unsafe" else "SAFE"
-            rows.append(dict(id=it["id"], pattern=it["pattern"], shape=it["shape"],
-                             label=it["label"], prompt=pi, verdict=v, verdict_class=cls,
-                             correct=(v == want), tokens=g["generation_tokens"],
-                             finish=g["finish_reason"], output=g["raw_output"]))
+            row = dict(id=it["id"], pattern=it["pattern"], shape=it["shape"],
+                       label=it["label"], prompt=pi, verdict=v, verdict_class=cls,
+                       correct=(v == want), tokens=g["generation_tokens"],
+                       finish=g["finish_reason"], output=g["raw_output"])
+            rows.append(row)
+            fh.write(json.dumps(row) + "\n"); fh.flush()
         done = (i+1) * a.prompts
         if (i+1) % 5 == 0:
             r = done / (time.time()-t0)
             print(f"  {done}/{total}  eta {(total-done)/r/60:.0f}m", flush=True)
 
-    os.makedirs(a.outdir, exist_ok=True)
+    fh.close()
     out = os.path.join(a.outdir, f"guardbench_{a.tag}.json")
     json.dump(dict(tag=a.tag, model=a.model, adapter=a.adapter, rows=rows), open(out, "w"), indent=1)
     report(rows, a.tag, out)