File size: 6,057 Bytes
aeaff79 | 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 | #!/usr/bin/env python3
# /// script
# dependencies = ["torch", "transformers", "accelerate"]
# ///
"""Proper eval of sakthai-plus models on sakthai-bench-v2.
Uses tokenizer.apply_chat_template with tools= (identical to training rendering).
Env: MODEL, SAMPLE, BATCH, MAX_NEW, DUMP
"""
import os, json, re, time, collections, urllib.request
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
MODEL = os.environ.get("MODEL", "Nanthasit/sakthai-plus-1.5b")
BATCH = int(os.environ.get("BATCH", "1"))
SAMPLE = int(os.environ.get("SAMPLE", "50"))
MAX_NEW = int(os.environ.get("MAX_NEW", "128"))
DUMP = int(os.environ.get("DUMP", "3"))
URL = "https://huggingface.co/datasets/Nanthasit/sakthai-bench-v2/resolve/main/data/test.jsonl"
print(f"Loading {URL} ...", flush=True)
with urllib.request.urlopen(URL) as f:
TEST = [json.loads(line) for line in f.read().decode().strip().splitlines()]
if SAMPLE:
import random
random.seed(42)
TEST = random.sample(TEST, min(SAMPLE, len(TEST)))
print(f"Loaded {len(TEST)} test rows", flush=True)
def parse_tool_calls(text):
calls = []
for m in re.finditer(r'<tool_call>\s*(.*?)\s*</tool_call>', text, re.DOTALL):
try:
obj = json.loads(m.group(1))
args = obj.get("arguments", {})
if isinstance(args, str):
try:
args = json.loads(args)
except json.JSONDecodeError:
pass
calls.append({"name": obj.get("name", ""), "arguments": args})
except json.JSONDecodeError:
pass
return calls
def norm_args(a):
if isinstance(a, str):
try:
a = json.loads(a)
except json.JSONDecodeError:
return str(a)
if isinstance(a, dict):
return {k: norm_args(v) for k, v in sorted(a.items()) if v is not None}
return a
def norm_call(c):
return {"name": c.get("name", ""), "arguments": norm_args(c.get("arguments", {}))}
def match_score(gold_calls, pred_calls):
gs = {json.dumps(norm_call(c), sort_keys=True) for c in gold_calls}
ps = {json.dumps(norm_call(c), sort_keys=True) for c in pred_calls}
if not gs and not ps:
return True, True
correct = gs == ps
args_ok = all(any(g["name"] == p["name"] and g["arguments"] == p["arguments"]
for p in pred_calls) for g in gold_calls) if pred_calls else False
return correct, args_ok
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Device: {device}", flush=True)
print(f"Loading tokenizer {MODEL} ...", flush=True)
tokenizer = AutoTokenizer.from_pretrained(MODEL)
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "left"
print(f"Loading model {MODEL} ...", flush=True)
model = AutoModelForCausalLM.from_pretrained(
MODEL,
torch_dtype=torch.float16,
device_map="auto" if device == "cuda" else None,
low_cpu_mem_usage=True,
).to(device)
model.eval()
print("Model loaded", flush=True)
results = collections.defaultdict(lambda: {"sel": [], "args": [], "strict": []})
held_results = collections.defaultdict(lambda: {"sel": [], "args": [], "strict": []})
t0 = time.time()
for i in range(0, len(TEST), BATCH):
batch = TEST[i:i + BATCH]
prompts = []
for row in batch:
msgs = list(row.get("messages", []))
while msgs and msgs[-1].get("role") in ("assistant", "tool"):
msgs.pop()
prompts.append(tokenizer.apply_chat_template(
msgs, tools=row.get("tools") or None,
tokenize=False, add_generation_prompt=True,
))
inputs = tokenizer(prompts, return_tensors="pt", padding=True, truncation=True, max_length=2048).to(device)
with torch.no_grad():
outputs = model.generate(
**inputs,
max_new_tokens=MAX_NEW,
do_sample=False,
pad_token_id=tokenizer.pad_token_id,
)
for j, row in enumerate(batch):
input_len = inputs["input_ids"].shape[1]
gen = tokenizer.decode(outputs[j][input_len:], skip_special_tokens=True)
pred_calls = parse_tool_calls(gen)
gold_calls = row.get("gold_calls", [])
category = row.get("category", "unknown")
held = row.get("held_out_tool", False)
correct, args_ok = match_score(gold_calls, pred_calls)
target = held_results if held else results
target[category]["sel"].append(correct)
target[category]["args"].append(args_ok)
target[category]["strict"].append(correct and args_ok)
if DUMP and j < DUMP:
print(f"\n--- Row {i + j} ({category}) ---", flush=True)
print(f"GOLD: {gold_calls}", flush=True)
print(f"PRED: {pred_calls}", flush=True)
print(f"RAW: {gen[:200]!r}", flush=True)
print(f"CORRECT: {correct}", flush=True)
elapsed = time.time() - t0
print(f" [{i + len(batch)}/{len(TEST)}] {elapsed:.0f}s elapsed", flush=True)
print("\n" + "=" * 60)
print("RESULTS")
print("=" * 60)
all_sel, all_args, all_strict = [], [], []
for cat in sorted(results):
r = results[cat]
n = len(r["sel"])
sel = sum(r["sel"]) / n * 100 if n else 0
args = sum(r["args"]) / n * 100 if n else 0
strict = sum(r["strict"]) / n * 100 if n else 0
all_sel.extend(r["sel"]); all_args.extend(r["args"]); all_strict.extend(r["strict"])
print(f" {cat:20s} selection={sel:.1f} arguments={args:.1f} strict={strict:.1f} n={n}")
if all_sel:
n = len(all_sel)
print(f"\n {'AVERAGE':20s} selection={sum(all_sel)/n*100:.1f} arguments={sum(all_args)/n*100:.1f} strict={sum(all_strict)/n*100:.1f} n={n}")
hs, ha, hst = [], [], []
for cat in sorted(held_results):
r = held_results[cat]
hs.extend(r["sel"]); ha.extend(r["args"]); hst.extend(r["strict"])
if hs:
n = len(hs)
print(f"\n {'HELD AVG':20s} selection={sum(hs)/n*100:.1f} arguments={sum(ha)/n*100:.1f} strict={sum(hst)/n*100:.1f} n={n}")
print(f"\nTotal time: {time.time() - t0:.0f}s")
|