| from __future__ import annotations |
|
|
| import argparse |
| import datetime as dt |
| import json |
| import os |
| import random |
| import re |
| import time |
| import urllib.request |
| from pathlib import Path |
|
|
|
|
| SYSTEM_PROMPT = ( |
| "You are solving exact-answer reasoning problems. " |
| "Follow the requested reasoning style exactly. " |
| "Always end with a single final line formatted as ANSWER: <answer>." |
| ) |
|
|
|
|
| CONDITIONS = { |
| "direct": ( |
| "Solve the problem internally. " |
| "Return only the final line. " |
| "End with one line exactly in the form ANSWER: <answer>." |
| ), |
| "english": ( |
| "Reason step by step in plain English. " |
| "Keep the reasoning concise but explicit. " |
| "End with one line exactly in the form ANSWER: <answer>." |
| ), |
| "pseudocode": ( |
| "Reason in terse pseudocode with explicit running state updates. " |
| "Prefer lines like `x = ...`, `total = ...`, `state -> ...`. " |
| "End with one line exactly in the form ANSWER: <answer>." |
| ), |
| "lojban": ( |
| "Reason in Lojban before giving the answer. " |
| "End with one line exactly in the form ANSWER: <answer>." |
| ), |
| } |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--models", nargs="+", required=True) |
| parser.add_argument("--conditions", nargs="+", required=True, choices=sorted(CONDITIONS)) |
| parser.add_argument("--output-dir", required=True) |
| parser.add_argument("--task-count", type=int, default=18) |
| parser.add_argument("--seed", type=int, default=20260406) |
| parser.add_argument("--lojban-pilot-count", type=int, default=0) |
| return parser.parse_args() |
|
|
|
|
| def make_arithmetic_task(rng: random.Random, task_id: str) -> dict[str, str]: |
| a = rng.randint(14, 49) |
| b = rng.randint(5, 17) |
| c = rng.randint(3, 11) |
| d = rng.randint(2, 9) |
| e = rng.randint(6, 15) |
| start = rng.randint(20, 80) |
| answer = ((start + a + b) * c) - (d * e) |
| prompt = ( |
| f"Start with {start}. Add {a}. Add {b}. Multiply the result by {c}. " |
| f"Subtract {d} times {e}. What number do you get?" |
| ) |
| return {"id": task_id, "kind": "arithmetic", "prompt": prompt, "answer": str(answer)} |
|
|
|
|
| def make_state_task(rng: random.Random, task_id: str) -> dict[str, str]: |
| prompt = ( |
| "Run this exact program and report the final value of x - y.\n\n" |
| f"x = {rng.randint(2, 8)}\n" |
| f"y = {rng.randint(3, 9)}\n" |
| f"z = {rng.randint(4, 10)}\n" |
| ) |
| prompt_lines = prompt.splitlines() |
| base_x = int(prompt_lines[2].split("=")[1].strip()) |
| base_y = int(prompt_lines[3].split("=")[1].strip()) |
| base_z = int(prompt_lines[4].split("=")[1].strip()) |
| x = base_x |
| y = base_y |
| z = base_z |
| lines = [ |
| f"x = x + y", |
| f"y = y * 2", |
| f"z = z + x - 1", |
| f"x = x * z", |
| f"y = y + z", |
| ] |
| x = x + y |
| y = y * 2 |
| z = z + x - 1 |
| x = x * z |
| y = y + z |
| answer = x - y |
| prompt = ( |
| "Run this exact program and report the final value of x - y.\n\n" |
| f"x = {base_x}\n" |
| f"y = {base_y}\n" |
| f"z = {base_z}\n" |
| + "\n".join(lines) |
| ) |
| return {"id": task_id, "kind": "state", "prompt": prompt, "answer": str(answer)} |
|
|
|
|
| def make_tasks(task_count: int, seed: int) -> list[dict[str, str]]: |
| rng = random.Random(seed) |
| tasks: list[dict[str, str]] = [] |
| for index in range(task_count): |
| task_id = f"task-{index + 1:02d}" |
| if index % 2 == 0: |
| tasks.append(make_arithmetic_task(rng, task_id)) |
| else: |
| tasks.append(make_state_task(rng, task_id)) |
| return tasks |
|
|
|
|
| def extract_answer(text: str) -> str: |
| matches = re.findall(r"ANSWER:\s*(.+)", text) |
| return matches[-1].strip() if matches else "" |
|
|
|
|
| def chat_completion(model: str, prompt: str) -> dict: |
| payload = { |
| "model": model, |
| "temperature": 0, |
| "messages": [ |
| {"role": "system", "content": SYSTEM_PROMPT}, |
| {"role": "user", "content": prompt}, |
| ], |
| } |
| body = json.dumps(payload).encode("utf-8") |
| request = urllib.request.Request( |
| "https://api.openai.com/v1/chat/completions", |
| data=body, |
| headers={ |
| "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}", |
| "Content-Type": "application/json", |
| }, |
| method="POST", |
| ) |
| with urllib.request.urlopen(request) as response: |
| return json.loads(response.read().decode("utf-8")) |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| timestamp = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ") |
| output_dir = Path(args.output_dir) / timestamp |
| output_dir.mkdir(parents=True, exist_ok=False) |
|
|
| tasks = make_tasks(args.task_count, args.seed) |
| (output_dir / "tasks.json").write_text(json.dumps(tasks, indent=2) + "\n") |
|
|
| raw_path = output_dir / "raw.jsonl" |
| rows: list[dict] = [] |
|
|
| for model in args.models: |
| for condition in args.conditions: |
| active_tasks = tasks |
| if condition == "lojban" and args.lojban_pilot_count: |
| active_tasks = tasks[: args.lojban_pilot_count] |
| for task in active_tasks: |
| prompt = f"{CONDITIONS[condition]}\n\nProblem:\n{task['prompt']}" |
| started_at = time.time() |
| response = chat_completion(model, prompt) |
| ended_at = time.time() |
| content = response["choices"][0]["message"]["content"] |
| prediction = extract_answer(content) |
| row = { |
| "model": model, |
| "condition": condition, |
| "task_id": task["id"], |
| "task_kind": task["kind"], |
| "gold_answer": task["answer"], |
| "predicted_answer": prediction, |
| "correct": prediction == task["answer"], |
| "latency_s": round(ended_at - started_at, 3), |
| "usage": response.get("usage", {}), |
| "response_id": response.get("id", ""), |
| "prompt": prompt, |
| "content": content, |
| } |
| rows.append(row) |
| with raw_path.open("a", encoding="utf-8") as handle: |
| handle.write(json.dumps(row) + "\n") |
|
|
| (output_dir / "results.json").write_text(json.dumps(rows, indent=2) + "\n") |
|
|
| summaries: list[dict] = [] |
| for model in args.models: |
| for condition in args.conditions: |
| active_rows = [row for row in rows if row["model"] == model and row["condition"] == condition] |
| correct = sum(1 for row in active_rows if row["correct"]) |
| total = len(active_rows) |
| summaries.append( |
| { |
| "model": model, |
| "condition": condition, |
| "correct": correct, |
| "total": total, |
| "accuracy": round(correct / total, 4), |
| } |
| ) |
| (output_dir / "summary.json").write_text(json.dumps(summaries, indent=2) + "\n") |
|
|
| samples: list[str] = ["# Manual Samples", ""] |
| for model in args.models: |
| for condition in args.conditions: |
| subset = [row for row in rows if row["model"] == model and row["condition"] == condition][:2] |
| samples.append(f"## {model} / {condition}") |
| samples.append("") |
| for row in subset: |
| samples.append(f"- {row['task_id']} `{row['task_kind']}` correct={row['correct']}") |
| samples.append(f" prompt: {row['prompt']}") |
| samples.append(f" output: {row['content']}") |
| samples.append("") |
| (output_dir / "samples.md").write_text("\n".join(samples) + "\n") |
|
|
| print(output_dir) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
