| from __future__ import annotations |
|
|
| import argparse |
| import datetime as dt |
| import json |
| import random |
| import re |
| from pathlib import Path |
|
|
| from mlx_lm import generate, load |
| from mlx_lm.sample_utils import make_sampler |
|
|
|
|
| SYSTEM_PROMPT = ( |
| "Solve exact-answer reasoning problems. " |
| "Inside the think block, reason in pseudocode only. " |
| "Do not use English prose inside the think block. " |
| "After thinking, end with exactly one line formatted as ANSWER: <answer>." |
| ) |
|
|
|
|
| USER_INSTRUCTION = ( |
| "Inside the think block, reason in pseudocode only. " |
| "Do not use English prose inside the think block. " |
| "Prefer lines like `x = 51`, `x = x + 34`, `state -> x = 85`." |
| ) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--model", required=True) |
| parser.add_argument("--output-dir", required=True) |
| parser.add_argument("--task-count", type=int, default=100) |
| parser.add_argument("--seed", type=int, default=20260407) |
| parser.add_argument("--max-tokens", type=int, default=1024) |
| parser.add_argument("--adapter-path") |
| parser.add_argument("--label", required=True) |
| parser.add_argument("--temp", type=float, default=0.6) |
| parser.add_argument("--top-p", type=float, default=0.95) |
| parser.add_argument("--top-k", type=int, default=20) |
| 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]: |
| base_x = rng.randint(2, 8) |
| base_y = rng.randint(3, 9) |
| base_z = rng.randint(4, 10) |
| x = base_x |
| y = base_y |
| z = base_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" |
| "x = x + y\n" |
| "y = y * 2\n" |
| "z = z + x - 1\n" |
| "x = x * z\n" |
| "y = y + z" |
| ) |
| 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 = [] |
| for index in range(task_count): |
| task_id = f"task-{index + 1:04d}" |
| if rng.random() < 0.5: |
| tasks.append(make_arithmetic_task(rng, task_id)) |
| else: |
| tasks.append(make_state_task(rng, task_id)) |
| return tasks |
|
|
|
|
| def normalize_answer(text: str) -> str: |
| return re.sub(r"[^0-9-]", "", text.strip()) |
|
|
|
|
| def extract_answer(text: str) -> str: |
| tagged = re.findall(r"<answer>\s*(.*?)\s*</answer>", text, flags=re.DOTALL | re.IGNORECASE) |
| if tagged: |
| return normalize_answer(tagged[-1]) |
| matches = re.findall(r"ANSWER:\s*(.+)", text) |
| return normalize_answer(matches[-1]) if matches else "" |
|
|
|
|
| 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) / f"{timestamp}-{args.label}" |
| 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") |
|
|
| model, tokenizer = load(args.model, adapter_path=args.adapter_path) |
| sampler = make_sampler(temp=args.temp, top_p=args.top_p, top_k=args.top_k) |
| rows = [] |
| raw_path = output_dir / "raw.jsonl" |
|
|
| for task in tasks: |
| messages = [ |
| {"role": "system", "content": SYSTEM_PROMPT}, |
| {"role": "user", "content": f"{USER_INSTRUCTION}\n\nProblem:\n{task['prompt']}"}, |
| ] |
| prompt = tokenizer.apply_chat_template( |
| messages, |
| tokenize=False, |
| add_generation_prompt=True, |
| enable_thinking=True, |
| ) |
| output = generate( |
| model, |
| tokenizer, |
| prompt=prompt, |
| max_tokens=args.max_tokens, |
| sampler=sampler, |
| verbose=False, |
| ) |
| prediction = extract_answer(output) |
| row = { |
| "label": args.label, |
| "task_id": task["id"], |
| "task_kind": task["kind"], |
| "gold_answer": task["answer"], |
| "predicted_answer": prediction, |
| "correct": prediction == normalize_answer(task["answer"]), |
| "output": output, |
| } |
| 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") |
| correct = sum(1 for row in rows if row["correct"]) |
| summary = { |
| "label": args.label, |
| "correct": correct, |
| "total": len(rows), |
| "accuracy": round(correct / len(rows), 4), |
| } |
| (output_dir / "summary.json").write_text(json.dumps(summary, indent=2) + "\n") |
| print(output_dir) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
