Datasets:
Download scripts/run_eval.py from Lilambd/empire-eval: direct link, hf CLI and curl.
- Browser
- Download file 15.7 kB
-
https://huggingface.co/datasets/Lilambd/empire-eval/resolve/main/scripts/run_eval.py
- Command line
-
hf download hf://datasets/Lilambd/empire-eval/scripts/run_eval.py
-
curl -L -o run_eval.py https://huggingface.co/datasets/Lilambd/empire-eval/resolve/main/scripts/run_eval.py
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())) | |