| |
| """Run GuardBench. |
| |
| Scoring never reports a single accuracy number, because the item classes are unbalanced (32 |
| unsafe, 8 safe) and raw accuracy rewards a model that always says VULNERABLE. The headline is |
| balanced accuracy - the mean of per-class recall - so always-vulnerable and always-safe both |
| score 50 percent. |
| |
| Verdicts are parsed from a required final line. A missing line is a scored failure. Each item is |
| asked three ways, because a model whose verdict line depends on the exact prompt phrasing is not |
| reliable and the benchmark should surface that rather than pick its best wording. |
| """ |
| import os, sys, json, re, argparse, time |
| from collections import Counter, defaultdict |
|
|
| ROOT = os.path.expanduser("~/loreacyber-ft") |
| sys.path.insert(0, os.path.join(ROOT, "eval")) |
| from raw_generation import build_chat_prompt, generate_raw |
|
|
| SYS = ("You are a security code reviewer. Follow the data flow from untrusted input to the sink, " |
| "and check whether any guard that exists is actually applied to the value that reaches it " |
| "and addresses the weakness in question.\n\n" |
| "End your reply with exactly one line, nothing after it:\n" |
| "VERDICT: VULNERABLE <short class>\n" |
| "or\n" |
| "VERDICT: SAFE") |
|
|
| PROMPTS = [ |
| "Review this code for security problems.\n\n{code}", |
| "Analyze this code for security issues:\n\n{code}", |
| "Is there a vulnerability in this code? Explain your reasoning.\n\n{code}", |
| ] |
|
|
| VERDICT = re.compile(r"^\s*VERDICT:\s*(VULNERABLE|SAFE)\b(.*)$", re.I | re.M) |
|
|
| def parse(text): |
| if "</think>" in text: |
| text = text.split("</think>")[-1] |
| ms = list(VERDICT.finditer(text)) |
| if not ms: |
| return None, None |
| return ms[-1].group(1).upper(), ms[-1].group(2).strip() |
|
|
| def wilson(k, n, z=1.96): |
| if n == 0: return (0.0, 0.0) |
| p = k / n; d = 1 + z*z/n |
| c = (p + z*z/(2*n)) / d |
| m = z * ((p*(1-p) + z*z/(4*n))/n) ** 0.5 / d |
| return max(0.0, c-m), min(1.0, c+m) |
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--model", default="/Volumes/ASAFE/strix/qwen38-27b-4bit") |
| ap.add_argument("--adapter", default=None) |
| ap.add_argument("--tag", required=True) |
| ap.add_argument("--max-tokens", type=int, default=400) |
| ap.add_argument("--prompts", type=int, default=3, help="how many phrasings per item") |
| ap.add_argument("--items", default=os.path.join(ROOT, "guardbench/items.jsonl")) |
| ap.add_argument("--outdir", default=os.path.join(ROOT, "guardbench/results")) |
| 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) |
|
|
| 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" |
| 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) |
|
|
| 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) |
|
|
| def report(rows, tag, path=None): |
| n = len(rows) |
| byshape = defaultdict(list) |
| for r in rows: byshape[r["shape"]].append(r) |
| safe = [r for r in rows if r["label"] == "safe"] |
| unsafe = [r for r in rows if r["label"] == "unsafe"] |
| rec_safe = sum(r["correct"] for r in safe) / max(1, len(safe)) |
| rec_unsafe = sum(r["correct"] for r in unsafe) / max(1, len(unsafe)) |
| bal = (rec_safe + rec_unsafe) / 2 |
| nov = sum(1 for r in rows if r["verdict"] is None) |
|
|
| print(f"\n=== GuardBench: {tag} ===") |
| print(f" BALANCED ACCURACY {bal:.1%} <- headline (always-vuln and always-safe both score 50%)") |
| print(f" recall on unsafe {rec_unsafe:.1%} ({sum(r['correct'] for r in unsafe)}/{len(unsafe)})") |
| print(f" recall on safe {rec_safe:.1%} ({sum(r['correct'] for r in safe)}/{len(safe)})") |
| print(f" raw accuracy {sum(r['correct'] for r in rows)/n:.1%} (do not quote this alone)") |
| print(f" no verdict line {nov}/{n} = {nov/n:.1%} <- brittleness") |
| print("\n by shape:") |
| for sh in ("none","covers","wrong_value","irrelevant","elsewhere"): |
| rs = byshape.get(sh, []) |
| if not rs: continue |
| k = sum(r["correct"] for r in rs) |
| lo, hi = wilson(k, len(rs)) |
| note = {"covers":"false alarms here", "irrelevant":"the guard-is-enough trap", |
| "elsewhere":"helper exists, call site skips it", |
| "wrong_value":"guard on the sibling value"}.get(sh, "") |
| print(f" {sh:12} {k:>3}/{len(rs):<3} = {k/len(rs):>6.1%} [{lo:.0%},{hi:.0%}] {note}") |
| print("\n by prompt phrasing (verdict-line rate):") |
| for pi in sorted({r["prompt"] for r in rows}): |
| rs = [r for r in rows if r["prompt"] == pi] |
| got = sum(1 for r in rs if r["verdict"] is not None) |
| k = sum(r["correct"] for r in rs) |
| print(f" prompt {pi} verdict {got}/{len(rs)} correct {k/len(rs):.1%}") |
| tk = sorted(r["tokens"] for r in rows) |
| print(f"\n median tokens {tk[len(tk)//2]}") |
| if path: print(f" saved {path}") |
|
|
| if __name__ == "__main__": |
| main() |
|
|
