scripts/eval_mlx_reasoning_adapter.py

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