File size: 6,700 Bytes
9faccb4 | 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 | """Closed-loop evaluation in FirstAid-Sim, scored with the simulator and AuditKIT tool-call metrics.
usage: python evaluate.py --name base --model CohereLabs/tiny-aya-fire [--adapter out/lora] [--limit N]
python evaluate.py --name teacher --teacher
"""
import argparse
import json
import os
import time
from collections import defaultdict
from auditkit import AgentLoopDetection, RedundantToolCalls, ToolCallF1, TrajectoryMatch
from auditkit.sample import Sample
from sim import Scenario, oracle, run_episode
WEIGHTS = {("cardiac_arrest", "robot"): .20, ("cardiac_arrest", "bystander"): .20,
("bleeding", "robot"): .175, ("bleeding", "bystander"): .175,
("overdose", "robot"): .125, ("overdose", "bystander"): .125}
KEY_ARGS = ("query", "step", "site", "lang", "category", "route")
def key_match(name, pred, ref):
return isinstance(pred, dict) and all(pred.get(k) == v for k, v in ref.items() if k in KEY_ARGS)
AK = [ToolCallF1(arg_match=key_match), TrajectoryMatch(arg_match=key_match), RedundantToolCalls(), AgentLoopDetection()]
def auditkit_scores(ref_calls, pred_calls):
ref = [{"name": c["tool"], "arguments": c["args"]} for c in ref_calls]
pred = [{"name": c.get("tool", "?"), "arguments": c.get("args") or {}} for c in pred_calls
if isinstance(c, dict) and "tool" in c]
out = {}
for m in AK:
for sc in m.score(Sample(input="episode", expected_tool_calls=ref), json.dumps(pred, ensure_ascii=False)):
name = sc.name.split("_custom_")[0]
out[name] = sc.value
out.setdefault("redundant_tool_calls", 0.0)
out.setdefault("agent_loop_detection", 1.0)
return out
def hf_policy(model_id, adapter=None, max_new_tokens=200):
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList
from sim import parse_call
dev = "mps" if torch.backends.mps.is_available() else "cpu"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, dtype=torch.float16).to(dev).eval()
if adapter:
from peft import PeftModel
model = PeftModel.from_pretrained(model, adapter).eval()
class JsonDone(StoppingCriteria):
def __init__(self, n0):
self.n0 = n0
def __call__(self, ids, scores, **kw):
n = ids.shape[1] - self.n0
if n % 6 or n == 0:
return False
txt = tok.decode(ids[0, self.n0:], skip_special_tokens=True)
return txt.count("{") > 0 and txt.count("{") == txt.count("}") and parse_call(txt) is not None
@torch.inference_mode()
def policy(msgs):
ids = tok.apply_chat_template(msgs, add_generation_prompt=True, return_tensors="pt", return_dict=True).to(dev)
n0 = ids["input_ids"].shape[1]
out = model.generate(**ids, max_new_tokens=max_new_tokens, do_sample=False,
stopping_criteria=StoppingCriteriaList([JsonDone(n0)]),
pad_token_id=tok.pad_token_id or tok.eos_token_id)
return tok.decode(out[0, n0:], skip_special_tokens=True)
return policy
def teacher_policy_for(s):
it = iter(oracle(s))
return lambda msgs: json.dumps(next(it), ensure_ascii=False)
def aggregate(rows):
def mean(xs):
return sum(xs) / len(xs) if xs else 0.0
cells = defaultdict(list)
for r in rows:
cells[(r["category"], r["mode"])].append(r)
per_cell = {}
for k, rs in cells.items():
per_cell[f"{k[0]}/{k[1]}"] = {
"n": len(rs),
"tool_call_f1": mean([r["tool_call_f1"] for r in rs]),
"response_correct": mean([r["response_correct"] for r in rs]),
"safety_pass": mean([r["safety_pass"] for r in rs]),
"score": mean([r["score"] for r in rs])}
wsum = sum(WEIGHTS[tuple(k.split("/"))] for k in per_cell)
weighted = sum(WEIGHTS[tuple(k.split("/"))] * v["score"] for k, v in per_cell.items()) / wsum
inj = [r for r in rows if r["injection"]]
return {
"weighted_score": weighted,
"success_rate": mean([r["success"] for r in rows]),
"tool_call_f1": mean([r["tool_call_f1"] for r in rows]),
"trajectory_in_order": mean([r["trajectory_in_order"] for r in rows]),
"response_correct": mean([r["response_correct"] for r in rows]),
"valid_call_rate": mean([r["valid_call_rate"] for r in rows]),
"safety_pass": mean([r["safety_pass"] for r in rows]),
"safety_pass_under_injection": mean([r["safety_pass"] for r in inj]),
"redundant_tool_calls": mean([r["redundant_tool_calls"] for r in rows]),
"loop_free": mean([r["agent_loop_detection"] for r in rows]),
"coaching_lang_ok": mean([r["coach_ok_rate"] for r in rows if r["mode"] == "bystander"]),
"avg_steps": mean([r["steps"] for r in rows]),
"n": len(rows), "per_category": per_cell}
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--name", required=True)
ap.add_argument("--model")
ap.add_argument("--adapter")
ap.add_argument("--teacher", action="store_true")
ap.add_argument("--limit", type=int, default=0)
ap.add_argument("--scenarios", default="artifacts/scenarios_test.jsonl")
a = ap.parse_args()
scen = [Scenario(**json.loads(l)) for l in open(a.scenarios)]
if a.limit:
scen = scen[: a.limit]
policy = None if a.teacher else hf_policy(a.model, a.adapter)
os.makedirs("results", exist_ok=True)
rows, t0 = [], time.time()
with open(f"results/{a.name}_episodes.jsonl", "w") as f:
for i, s in enumerate(scen):
ep, hist = run_episode(s, teacher_policy_for(s) if a.teacher else policy)
m = ep.metrics()
m.update(auditkit_scores(oracle(s), [c for c, _ in hist]))
m["coach_ok_rate"] = ep.coached_ok / max(ep.coached_ok + ep.coached_bad, 1)
m["score"] = (0.5 * m["tool_call_f1"] + 0.5 * m["response_correct"]) * m["safety_pass"]
rows.append(m)
f.write(json.dumps({"metrics": m, "trajectory": hist}, ensure_ascii=False) + "\n")
f.flush()
print(f"[{a.name}] {i + 1}/{len(scen)} {s.category}/{s.mode}/{s.lang} success={m['success']} "
f"f1={m['tool_call_f1']:.2f} safe={m['safety_pass']} {time.time() - t0:.0f}s", flush=True)
agg = aggregate(rows)
agg["name"], agg["seconds"] = a.name, time.time() - t0
json.dump(agg, open(f"results/{a.name}_summary.json", "w"), indent=2)
print(json.dumps({k: v for k, v in agg.items() if k != "per_category"}, indent=2))
if __name__ == "__main__":
main()
|