"""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()))