empire-eval / scripts /run_eval.py
Lilambd's picture
Publish Lilambd Empire Eval
7f9a652 verified
Raw History Blame Contribute Delete
15.7 kB
"""Run a model over Lilambd Empire Eval prompts and write predictions.jsonl.
Standard library only. Examples:
# build prompts on the fly from a QA folder, call Claude, score at the end
ANTHROPIC_API_KEY=... python scripts/run_eval.py --qa data/dev --provider anthropic \
--out results/sonnet/predictions.jsonl --score
# any OpenAI-compatible server (vLLM, Ollama, OpenRouter, Together, OpenAI)
python scripts/run_eval.py --qa data/dev --provider openai \
--base-url http://localhost:8000/v1 --model my-model --out results/m/predictions.jsonl
# prompts made by make_prompts.py
python scripts/make_prompts.py --qa data/test --out prompts.jsonl
python scripts/run_eval.py --prompts prompts.jsonl --provider anthropic --out preds.jsonl
# sanity baselines (no network): oracle (dev only), null, random-guess
python scripts/run_eval.py --qa data/dev --provider oracle --out /tmp/o.jsonl --score
Each output line: {"id", "answer", "raw", "latency_ms"}. Re-running with the same
--out resumes: ids already in the file are skipped. Failed calls are not written,
so a re-run retries them. Note score.py counts missing ids as wrong, so a --limit
or --sets run scored against the full --qa folder gives a low overall accuracy.
"""
import argparse, concurrent.futures, glob, json, os, random, re, subprocess, sys, threading, time
import urllib.error, urllib.request
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
from make_prompts import INSTR # noqa: E402 same instruction text as make_prompts.py
from package import unflat # noqa: E402 same answer decoding as score.py
ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages'
ANTHROPIC_VERSION = '2023-06-01'
DEFAULT_MODELS = {'anthropic': 'claude-sonnet-5-5', 'openai': 'gpt-4o-mini'}
RETRY_STATUS = {408, 409, 425, 429, 500, 502, 503, 504, 529}
# ---------------------------------------------------------------- inputs
def qa_files(qa):
return sorted(glob.glob(os.path.join(qa, '*.jsonl'))) if os.path.isdir(qa) else [qa]
def load_items(qa):
"""QA rows (decoded with package.unflat), with the file stem as `_set`."""
out = []
for fn in qa_files(qa):
stem = os.path.splitext(os.path.basename(fn))[0]
with open(fn, encoding='utf-8') as fh:
lines = fh.readlines()
for line in lines:
if line.strip():
it = unflat(json.loads(line))
it['_set'] = stem
out.append(it)
return out
def build_prompt(it, context_hint=False):
"""Byte-for-byte the prompt make_prompts.py writes."""
p = INSTR + '\n\n'
if context_hint:
p += f"Dataset: https://huggingface.co/datasets/{it['dataset']} (revision {it['revision']})\n"
if it.get('answer_format'):
p += f"Answer format: {it['answer_format']}\n"
p += f"Question: {it['question']}"
return p
def set_of_id(qid):
return qid.rsplit('-', 1)[0]
def in_sets(qid, set_name, sets):
if not sets:
return True
cands = {set_of_id(qid)}
if set_name:
cands.add(set_name)
return any(c == s or c.endswith('-' + s) for c in cands for s in sets)
def load_done(path):
done = set()
if os.path.exists(path):
with open(path, encoding='utf-8') as fh:
lines = fh.readlines()
for line in lines:
try:
done.add(json.loads(line)['id'])
except (json.JSONDecodeError, KeyError, TypeError):
pass # e.g. a half-written last line after a crash
return done
# ---------------------------------------------------------------- extraction
ANS_PREFIX = re.compile(r'^\s*(?:\*\*)?\s*(?:final\s+)?answer\s*(?:\*\*)?\s*[::]\s*(?:\*\*)?', re.I)
def extract_answer(raw):
"""Keep the last non-empty line and strip an 'Answer:' prefix.
A reply that is valid JSON as a whole (e.g. a multi-line list) is kept whole.
"""
if raw is None:
return None
s = str(raw).strip()
s = re.sub(r'^```[\w-]*\s*|\s*```$', '', s).strip()
try:
v = json.loads(s)
if isinstance(v, list):
return s.replace('\n', ' ') if '\n' in s else s
except (json.JSONDecodeError, ValueError):
pass
lines = [l for l in s.splitlines() if l.strip() and l.strip() != '```']
if not lines:
return ''
last = ANS_PREFIX.sub('', lines[-1]).strip()
last = re.sub(r'^\*\*(.*)\*\*$', r'\1', last).strip()
return last
# ---------------------------------------------------------------- HTTP
class HTTPFail(Exception):
pass
def post_json(url, headers, body, timeout, retries, backoff, log=None, _sleep=time.sleep):
data = json.dumps(body).encode('utf-8')
attempt = 0
while True:
req = urllib.request.Request(url, data=data, method='POST',
headers={'content-type': 'application/json', **headers})
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read().decode('utf-8'))
except urllib.error.HTTPError as e:
msg = ''
try:
msg = e.read().decode('utf-8', 'replace')[:500]
except Exception:
pass
if e.code not in RETRY_STATUS or attempt >= retries:
raise HTTPFail(f'HTTP {e.code}: {msg}') from None
wait = None
ra = e.headers.get('retry-after') if e.headers else None
if ra:
try:
wait = float(ra)
except ValueError:
pass
except (urllib.error.URLError, TimeoutError, ConnectionError, OSError) as e:
if attempt >= retries:
raise HTTPFail(f'network error: {e}') from None
wait = None
if wait is None:
wait = backoff * (2 ** attempt) * (0.5 + random.random())
wait = min(wait, 60.0)
if log:
log(f'retry {attempt + 1}/{retries} in {wait:.1f}s')
_sleep(wait)
attempt += 1
# ---------------------------------------------------------------- providers
def anthropic_request(a, prompt):
key = os.environ.get('ANTHROPIC_API_KEY')
if not key:
raise SystemExit('ANTHROPIC_API_KEY is not set')
body = {'model': a.model, 'max_tokens': a.max_tokens,
'messages': [{'role': 'user', 'content': prompt}]}
if a.temperature is not None:
body['temperature'] = a.temperature
if a.system:
body['system'] = a.system
headers = {'x-api-key': key, 'anthropic-version': ANTHROPIC_VERSION}
return (a.base_url or ANTHROPIC_URL), headers, body
def anthropic_text(resp):
return ''.join(b.get('text', '') for b in resp.get('content', []) if b.get('type') == 'text')
def openai_request(a, prompt):
base = (a.base_url or 'https://api.openai.com/v1').rstrip('/')
url = base if base.endswith('/chat/completions') else base + '/chat/completions'
msgs = ([{'role': 'system', 'content': a.system}] if a.system else []) + [{'role': 'user', 'content': prompt}]
body = {'model': a.model, 'messages': msgs, 'max_tokens': a.max_tokens}
if a.temperature is not None:
body['temperature'] = a.temperature
headers = {}
key = os.environ.get('OPENAI_API_KEY')
if key: # local servers (vLLM, Ollama) usually need none
headers['authorization'] = 'Bearer ' + key
return url, headers, body
def openai_text(resp):
ch = resp.get('choices') or [{}]
return (ch[0].get('message') or {}).get('content') or ''
API = {'anthropic': (anthropic_request, anthropic_text), 'openai': (openai_request, openai_text)}
YESNO = re.compile(r'^(is|are|was|were|does|do|did|has|have|had|can|could|will)\b', re.I)
def make_caller(a, gold):
"""Return fn(row) -> raw reply string."""
if a.provider in API:
build, text = API[a.provider]
def call(row):
url, headers, body = build(a, row['prompt'])
return text(post_json(url, headers, body, a.timeout, a.retries, a.backoff,
log=lambda m: print(f"[{row['id']}] {m}", file=sys.stderr)))
return call
if a.provider == 'oracle':
def call(row):
if row['id'] not in gold:
raise HTTPFail('oracle: no dev answer for this id (oracle needs --qa with answers)')
g = gold[row['id']]
return 'null' if g is None else json.dumps(g, ensure_ascii=False) if isinstance(g, list) else str(g)
return call
if a.provider == 'null':
return lambda row: 'null'
if a.provider == 'random-guess':
def call(row):
# Uses only the question text (never answer_type), seeded per id so runs repeat.
rng = random.Random(f"{a.seed}:{row['id']}")
q = row.get('question') or row['prompt'].rsplit('Question:', 1)[-1].strip()
if YESNO.match(q):
return rng.choice(['true', 'false'])
return str(rng.randint(0, 1000))
return call
raise SystemExit('unknown provider ' + a.provider)
# ---------------------------------------------------------------- main
def parse_args(argv=None):
ap = argparse.ArgumentParser(description=__doc__.split('\n')[0])
src = ap.add_argument_group('input')
src.add_argument('--qa', help='QA folder or .jsonl (builds prompts; needed by oracle and --score)')
src.add_argument('--prompts', help='prompts.jsonl from make_prompts.py (used instead of building)')
src.add_argument('--with-context-hint', action='store_true', help='as in make_prompts.py, when building')
src.add_argument('--sets', help='comma list of sets, e.g. world-earth,worlds-021-hibe')
src.add_argument('--limit', type=int, help='at most N questions (after --sets)')
m = ap.add_argument_group('model')
m.add_argument('--provider', required=True, choices=['anthropic', 'openai', 'oracle', 'null', 'random-guess'])
m.add_argument('--model')
m.add_argument('--base-url', help='openai: e.g. http://localhost:8000/v1, https://openrouter.ai/api/v1')
m.add_argument('--system', help='optional system prompt')
m.add_argument('--max-tokens', type=int, default=512)
m.add_argument('--temperature', type=float, default=0.0, help='use a negative value to omit it')
m.add_argument('--seed', type=int, default=0, help='random-guess seed')
r = ap.add_argument_group('run')
r.add_argument('--out', required=True, help='predictions.jsonl (appended to; resumes)')
r.add_argument('--concurrency', type=int, default=4)
r.add_argument('--retries', type=int, default=5)
r.add_argument('--backoff', type=float, default=1.0, help='base seconds for exponential backoff')
r.add_argument('--timeout', type=float, default=120.0)
r.add_argument('--no-resume', action='store_true', help='overwrite --out instead of resuming')
r.add_argument('--score', action='store_true', help='run score.py at the end (needs --qa)')
r.add_argument('--score-out', help='default: score.json next to --out')
a = ap.parse_args(argv)
if not a.qa and not a.prompts:
ap.error('give --qa or --prompts')
if a.provider == 'oracle' and not a.qa:
ap.error('oracle needs --qa (a folder with answers, e.g. data/dev)')
if a.score and not a.qa:
ap.error('--score needs --qa')
if a.temperature is not None and a.temperature < 0:
a.temperature = None
a.model = a.model or DEFAULT_MODELS.get(a.provider, a.provider)
return a
def select_rows(a):
items = load_items(a.qa) if a.qa else []
gold = {it['id']: it.get('answer') for it in items if 'answer' in it}
by_id = {it['id']: it for it in items}
sets = [s.strip() for s in a.sets.split(',') if s.strip()] if a.sets else []
rows = []
if a.prompts:
with open(a.prompts, encoding='utf-8') as fh:
plines = fh.readlines()
for line in plines:
if line.strip():
o = json.loads(line)
it = by_id.get(o['id'], {})
rows.append({'id': o['id'], 'prompt': o['prompt'], 'question': it.get('question'), '_set': it.get('_set')})
else:
rows = [{'id': it['id'], 'prompt': build_prompt(it, a.with_context_hint), 'question': it['question'],
'_set': it['_set']} for it in items]
rows = [r for r in rows if in_sets(r['id'], r.get('_set'), sets)]
if a.limit is not None:
rows = rows[:a.limit]
return rows, gold
def run(a):
rows, gold = select_rows(a)
os.makedirs(os.path.dirname(os.path.abspath(a.out)), exist_ok=True)
if a.no_resume and os.path.exists(a.out):
os.remove(a.out)
done = load_done(a.out)
todo = [r for r in rows if r['id'] not in done]
print(f'{len(rows)} selected, {len(rows) - len(todo)} already in {a.out}, {len(todo)} to run '
f'[{a.provider}:{a.model}]', file=sys.stderr)
call = make_caller(a, gold)
lock = threading.Lock()
stats = {'ok': 0, 'err': 0}
if os.path.exists(a.out) and os.path.getsize(a.out):
with open(a.out, 'rb') as fh:
fh.seek(-1, os.SEEK_END)
partial = fh.read(1) != b'\n'
if partial: # a crash left a half-written last line: drop it so the file stays valid JSONL
with open(a.out, 'rb') as fh:
data = fh.read()
with open(a.out, 'wb') as fh:
fh.write(data[:data.rfind(b'\n') + 1])
f = open(a.out, 'a', encoding='utf-8')
def work(row):
t0 = time.monotonic()
try:
raw = call(row)
except HTTPFail as e:
with lock:
stats['err'] += 1
print(f"[{row['id']}] FAILED: {e}", file=sys.stderr)
return
rec = {'id': row['id'], 'answer': extract_answer(raw), 'raw': raw,
'latency_ms': int(round((time.monotonic() - t0) * 1000))}
with lock:
f.write(json.dumps(rec, ensure_ascii=False) + '\n')
f.flush()
stats['ok'] += 1
n = stats['ok'] + stats['err']
if n % 100 == 0 or n == len(todo):
print(f' {n}/{len(todo)} done ({stats["err"]} failed)', file=sys.stderr)
try:
with concurrent.futures.ThreadPoolExecutor(max(1, a.concurrency)) as ex:
list(ex.map(work, todo))
finally:
f.close()
print(f'wrote {stats["ok"]} predictions to {a.out}; {stats["err"]} failed (re-run to retry)', file=sys.stderr)
rc = 1 if stats['err'] else 0
if a.score:
score_out = a.score_out or os.path.join(os.path.dirname(os.path.abspath(a.out)), 'score.json')
cmd = [sys.executable, os.path.join(HERE, 'score.py'), '--qa', a.qa, '--pred', a.out, '--out', score_out]
src = subprocess.call(cmd)
if src:
print(f'score.py failed (exit {src}); known case: a numeric reply to a string question whose gold '
f'looks numeric after normalising (e.g. world-sound-0216). scripts/score_guarded.py takes the '
f'same arguments and counts such pairs as wrong.', file=sys.stderr)
else:
print('score ->', score_out, file=sys.stderr)
rc = src or rc
return rc
if __name__ == '__main__':
sys.exit(run(parse_args()))