Datasets:

DaydreamerMZM
/

SenseMath

#!/usr/bin/env python3
"""
SenseMath v2 Judge Task Inference + Analysis (J1 / J2).
Supports both vLLM local models and OpenAI API.
Usage:
  # vLLM inference
  python run_judge_tasks.py --step inference --task j1 --model Qwen/Qwen3-30B-A3B-Instruct-2507 --tp 4
  # OpenAI API inference
  python run_judge_tasks.py --step inference --task j1 --api --api-model gpt-5-mini --concurrency 20
  # Run paper judge tasks at once
  python run_judge_tasks.py --step inference --task all --model Qwen/Qwen3-30B-A3B-Instruct-2507 --tp 4
  # Analyze results
  python run_judge_tasks.py --step analyze
"""

import os
import re
import json
import asyncio
import argparse
from pathlib import Path
from typing import List, Dict, Optional
from collections import defaultdict

from dataset_registry import J1_PROFILES, load_judge_dataset, validate_existing_results

SCRIPT_DIR = Path(__file__).parent
V2_DATA_DIR = SCRIPT_DIR.parent / "benchmark"
if not V2_DATA_DIR.exists():
    V2_DATA_DIR = SCRIPT_DIR.parent / "data"
V2_RESULTS_DIR = SCRIPT_DIR.parent / "results" / "paper-aligned-v1"
J1_PROFILE = "paper-filtered"


# ── Helpers ───────────────────────────────────────────────────────────────────

def safe_model_name(model: str) -> str:
    return re.sub(r"[/: ]", "_", model)


def load_json(path: Path) -> List[Dict]:
    with open(path) as f:
        return json.load(f)


def save_json(data, path: Path):
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)


def extract_yes_no(response: str) -> str:
    """Extract YES/NO from a J1 response."""
    text = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
    # Look for explicit YES/NO (case-insensitive)
    m = re.search(r"\b(YES|NO)\b", text, re.IGNORECASE)
    if m:
        return m.group(1).upper()
    return ""


def extract_strategy(response: str) -> str:
    """Extract SHORTCUT/COMPUTATION from a J2 strategy response."""
    text = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
    m = re.search(r"\b(SHORTCUT|COMPUTATION)\b", text, re.IGNORECASE)
    if m:
        return m.group(1).upper()
    return ""


def result_path(task: str, model_name: str) -> Path:
    scope = f"j1_{J1_PROFILE}" if task == "j1" else task
    return V2_RESULTS_DIR / f"judge_{scope}_{safe_model_name(model_name)}.json"


def build_record(item: Dict, task: str, model: str, raw_response: str, token_count: int,
                 dataset: Optional[Dict] = None) -> Dict:
    """Build a result record from a judge item and its response."""
    rec = {
        "task_id": item["task_id"],
        "task_type": item["task_type"],
        "category": item["category"],
        "model": model,
        "prompt": item["prompt"],
        "raw_response": raw_response,
        "response_token_count": token_count,
    }
    if dataset is not None:
        rec["dataset"] = dataset

    # Variant metadata is present in both public judge tasks.
    if "variant" in item:
        rec["variant"] = item["variant"]

    # Ground truth field differs by task
    if task == "j1":
        rec["ground_truth"] = item["ground_truth"]
        rec["predicted"] = extract_yes_no(raw_response)
    elif task == "j2":
        rec["ground_truth"] = item["ground_truth"]
        rec["predicted"] = extract_strategy(raw_response)
        rec["is_correct"] = rec["predicted"] == rec["ground_truth"]
        if "source_condition" in item:
            rec["source_condition"] = item["source_condition"]
        if "source_description" in item:
            rec["source_description"] = item["source_description"]

    return rec


# ── vLLM inference ────────────────────────────────────────────────────────────

def run_vllm_inference(args, task: str):
    from vllm import LLM, SamplingParams
    from transformers import AutoTokenizer

    model = args.model
    model_safe = safe_model_name(model)
    V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

    # Load dataset
    items, dataset = load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE)
    print(f"Loaded {len(items)} items: {dataset['task_key']}")

    # Load existing results for resumption
    out_path = result_path(task, model)
    existing = load_json(out_path) if out_path.exists() else []
    validate_existing_results(existing, items, dataset)
    done_ids = {r["task_id"] for r in existing}

    # Filter to pending items
    pending = [it for it in items if it["task_id"] not in done_ids]
    if not pending:
        print(f"All {task.upper()} items already done for {model}.")
        return
    print(f"Pending: {len(pending)} / {len(items)}")

    # Load tokenizer for chat template
    tok = AutoTokenizer.from_pretrained(
        model, trust_remote_code=True,
        cache_dir=os.environ.get("HF_HOME"),
    )
    chat = hasattr(tok, "chat_template") and tok.chat_template
    is_thinking_model = "enable_thinking" in (tok.chat_template or "")

    def apply_template(prompt: str) -> str:
        if chat:
            messages = [{"role": "user", "content": prompt}]
            try:
                kwargs = dict(tokenize=False, add_generation_prompt=True)
                if is_thinking_model:
                    kwargs["enable_thinking"] = False
                return tok.apply_chat_template(messages, **kwargs)
            except Exception:
                pass
        return prompt

    # Build prompts
    prompts = [apply_template(it["prompt"]) for it in pending]

    # Load vLLM
    llm_kwargs = dict(
        model=model, dtype="bfloat16",
        tensor_parallel_size=args.tp,
        gpu_memory_utilization=args.gpu_mem,
        trust_remote_code=True,
        max_model_len=2048,
    )
    if os.environ.get("HF_HOME"):
        llm_kwargs["download_dir"] = os.environ["HF_HOME"]

    print("Loading vLLM model...")
    llm = LLM(**llm_kwargs)
    sp = SamplingParams(temperature=0, max_tokens=args.max_tokens, seed=42)

    print(f"Running batch inference on {len(prompts)} prompts...")
    outputs = llm.generate(prompts, sp)

    new_records = []
    for out, item in zip(outputs, pending):
        raw = out.outputs[0].text.strip()
        tok_count = len(out.outputs[0].token_ids)
        rec = build_record(item, task, model, raw, tok_count, dataset)
        new_records.append(rec)

    all_records = existing + new_records
    save_json(all_records, out_path)
    print(f"Saved {len(all_records)} records -> {out_path}")


# ── API inference ─────────────────────────────────────────────────────────────

async def call_openai(client, model: str, prompt: str, max_tokens: int,
                      semaphore: asyncio.Semaphore):
    """Make a single OpenAI chat completion call with concurrency control."""
    async with semaphore:
        try:
            kwargs = dict(
                model=model,
                messages=[{"role": "user", "content": prompt}],
                max_completion_tokens=max_tokens,
            )
            # Some models don't support temperature=0
            if "5-mini" not in model and "o1" not in model and "o3" not in model and "o4" not in model:
                kwargs["temperature"] = 0
            response = await client.chat.completions.create(**kwargs)
            text = response.choices[0].message.content or ""
            token_count = response.usage.completion_tokens if response.usage else 0
            return text.strip(), token_count
        except Exception as e:
            print(f"  API error: {e}")
            return "", 0


async def run_api_inference_async(args, task: str):
    from openai import AsyncOpenAI

    api_key = os.environ.get("OPENAI_API_KEY")
    if not api_key:
        print("Error: OPENAI_API_KEY environment variable is not set.")
        return

    model = args.api_model
    model_safe = safe_model_name(model)
    V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

    # Load dataset
    items, dataset = load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE)
    print(f"Loaded {len(items)} items: {dataset['task_key']}")

    # Load existing results for resumption
    out_path = result_path(task, model)
    existing = load_json(out_path) if out_path.exists() else []
    validate_existing_results(existing, items, dataset)
    done_ids = {r["task_id"] for r in existing}

    pending = [it for it in items if it["task_id"] not in done_ids]
    if not pending:
        print(f"All {task.upper()} items already done for {model}.")
        return
    print(f"Pending: {len(pending)} / {len(items)}")

    client = AsyncOpenAI(api_key=api_key)
    semaphore = asyncio.Semaphore(args.concurrency)

    async_tasks = [
        call_openai(client, model, it["prompt"], args.max_tokens, semaphore)
        for it in pending
    ]

    print(f"Running {len(async_tasks)} API calls with concurrency={args.concurrency}...")
    results = await asyncio.gather(*async_tasks)

    new_records = []
    for item, (response_text, token_count) in zip(pending, results):
        rec = build_record(item, task, model, response_text, token_count, dataset)
        new_records.append(rec)

    all_records = existing + new_records
    save_json(all_records, out_path)
    print(f"Saved {len(all_records)} records -> {out_path}")

    await client.close()


def run_api_inference(args, task: str):
    asyncio.run(run_api_inference_async(args, task))


# ── Inference dispatcher ──────────────────────────────────────────────────────

def step_inference(args):
    tasks = ["j1", "j2"] if args.task == "all" else [args.task]

    for task in tasks:
        print(f"\n{'='*60}")
        print(f"  Judge task: {task.upper()}")
        print(f"{'='*60}")

        if args.api:
            run_api_inference(args, task)
        else:
            run_vllm_inference(args, task)


# ── Analysis ──────────────────────────────────────────────────────────────────

def step_analyze(args):
    V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

    # Discover all judge result files
    j1_files = sorted(V2_RESULTS_DIR.glob(f"judge_j1_{J1_PROFILE}_*.json"))
    j2_files = sorted(V2_RESULTS_DIR.glob("judge_j2_*.json"))

    if not j1_files and not j2_files:
        print("No judge result files found.")
        return

    print(f"\n{'='*80}")
    print(f"  SenseMath v2 Judge Task Analysis")
    print(f"{'='*80}")

    summary = {}
    selected = {task: load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE) for task in ("j1", "j2")}

    # ── J1 Analysis (YES/NO accuracy) ────────────────────────────────────
    if j1_files:
        print(f"\n--- J1: Strategy Appropriateness (YES/NO) ---")
        print(f"  {'Model':<35} {'N':>5} {'Acc%':>7} | "
              f"{'strong':>7} {'weak':>7} {'control':>7}")
        print(f"  {'-'*80}")

        for fpath in j1_files:
            records = load_json(fpath)
            validate_existing_results(records, *selected["j1"])
            if not records:
                continue
            model = records[0]["model"]
            model_short = model.split("/")[-1][:33]

            unlabeled = sum(r.get("ground_truth") is None for r in records)
            records = [r for r in records if r.get("ground_truth") is not None]
            total = len(records)
            correct = sum(1 for r in records if r.get("predicted") == r.get("ground_truth"))
            acc = correct / total if total else 0

            # Per-variant accuracy
            variant_acc = {}
            for var in ("strong_shortcut", "weak_shortcut", "control"):
                var_recs = [r for r in records if r.get("variant") == var]
                if var_recs:
                    va = sum(1 for r in var_recs if r.get("predicted") == r.get("ground_truth")) / len(var_recs)
                    variant_acc[var] = va
                else:
                    variant_acc[var] = float("nan")

            print(f"  {model_short:<35} {total:>5} {acc:>6.1%} | "
                  f"{variant_acc.get('strong_shortcut', 0):>6.1%} "
                  f"{variant_acc.get('weak_shortcut', 0):>6.1%} "
                  f"{variant_acc.get('control', 0):>6.1%}")

            # Per-category breakdown
            categories = sorted(set(r["category"] for r in records))
            cat_detail = {}
            for cat in categories:
                cat_recs = [r for r in records if r["category"] == cat]
                cat_acc = sum(1 for r in cat_recs if r.get("predicted") == r.get("ground_truth")) / len(cat_recs)
                cat_detail[cat] = round(cat_acc, 4)

            summary[f"J1|{safe_model_name(model)}"] = {
                "model": model, "task": "J1", "n": total, "unlabeled": unlabeled,
                "accuracy": round(acc, 4),
                "variant_accuracy": {k: round(v, 4) for k, v in variant_acc.items()},
                "category_accuracy": cat_detail,
            }

        # Detailed per-category table
        print(f"\n  J1 per-category breakdown:")
        for fpath in j1_files:
            records = [r for r in load_json(fpath) if r.get("ground_truth") is not None]
            if not records:
                continue
            model_short = records[0]["model"].split("/")[-1][:25]
            categories = sorted(set(r["category"] for r in records))
            print(f"    {model_short}:")
            for cat in categories:
                cat_recs = [r for r in records if r["category"] == cat]
                cat_acc = sum(1 for r in cat_recs if r.get("predicted") == r.get("ground_truth")) / len(cat_recs)
                print(f"      {cat:<30} {len(cat_recs):>4} items  {cat_acc:>6.1%}")

    # ── J2 Analysis (strategy identification accuracy) ───────────────────
    if j2_files:
        print(f"\n--- J2: Strategy Identification (SHORTCUT/COMPUTATION) ---")
        print(f"  {'Model':<35} {'N':>5} {'Acc%':>7} | "
              f"{'SHORT':>7} {'COMP':>7}")
        print(f"  {'-'*70}")

        for fpath in j2_files:
            records = load_json(fpath)
            validate_existing_results(records, *selected["j2"])
            if not records:
                continue
            model = records[0]["model"]
            model_short = model.split("/")[-1][:33]
            aligned = [r for r in records if "ground_truth" in r]
            n = len(aligned)
            correct = sum(1 for r in aligned if r.get("predicted") == r.get("ground_truth"))
            acc = correct / n if n else 0

            class_acc = {}
            for label in ("SHORTCUT", "COMPUTATION"):
                label_recs = [r for r in aligned if r.get("ground_truth") == label]
                class_acc[label] = (
                    sum(1 for r in label_recs if r.get("predicted") == label) / len(label_recs)
                    if label_recs else float("nan")
                )

            print(f"  {model_short:<35} {n:>5} {acc:>6.1%} | "
                  f"{class_acc.get('SHORTCUT', 0):>6.1%} "
                  f"{class_acc.get('COMPUTATION', 0):>6.1%}")

            summary[f"J2|{safe_model_name(model)}"] = {
                "model": model, "task": "J2", "n": n,
                "accuracy": round(acc, 4),
                "strategy_accuracy": {
                    "SHORTCUT": round(class_acc.get("SHORTCUT", 0), 4),
                    "COMPUTATION": round(class_acc.get("COMPUTATION", 0), 4),
                },
            }

    # Save summary
    out_path = V2_RESULTS_DIR / f"judge_analysis_{J1_PROFILE}.json"
    save_json(summary, out_path)
    print(f"\nSaved analysis -> {out_path}")


# ── Main ──────────────────────────────────────────────────────────────────────

def main():
    global V2_DATA_DIR, V2_RESULTS_DIR, J1_PROFILE
    parser = argparse.ArgumentParser(
        description="SenseMath v2 Judge Task Inference + Analysis (J1/J2)")

    parser.add_argument("--step", required=True,
                        choices=["inference", "analyze", "validate"])
    parser.add_argument("--task", default="all",
                        choices=["j1", "j2", "all"],
                        help="Which judge task to run. all runs paper J1/J2.")
    parser.add_argument("--data-dir", type=Path, default=V2_DATA_DIR,
                        help="Directory containing the shared dataset manifest (benchmark/ or HF data/).")
    parser.add_argument("--j1-profile", choices=list(J1_PROFILES), default="paper-filtered",
                        help="J1 full 300-item set or paper-filtered 261-item subset; never pooled.")

    # vLLM options
    parser.add_argument("--model", default="Qwen/Qwen3-30B-A3B-Instruct-2507",
                        help="HuggingFace model for vLLM")
    parser.add_argument("--tp", type=int, default=1,
                        help="Tensor parallel size for vLLM")
    parser.add_argument("--gpu-mem", type=float, default=0.90,
                        help="GPU memory utilization for vLLM")

    # API options
    parser.add_argument("--api", action="store_true",
                        help="Use OpenAI API instead of vLLM")
    parser.add_argument("--api-model", default="gpt-5-mini",
                        help="OpenAI model name (used with --api)")
    parser.add_argument("--concurrency", type=int, default=20,
                        help="Max concurrent API requests")

    # Shared
    parser.add_argument("--max-tokens", type=int, default=512,
                        help="Max tokens for generation")

    args = parser.parse_args()
    V2_DATA_DIR = args.data_dir
    J1_PROFILE = args.j1_profile
    manifest = load_json(V2_DATA_DIR / "manifest.json")
    V2_RESULTS_DIR = SCRIPT_DIR.parent / "results" / manifest["release_id"]

    if args.step == "validate":
        for task in (["j1", "j2"] if args.task == "all" else [args.task]):
            _, metadata = load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE)
            print(json.dumps(metadata, sort_keys=True))
    elif args.step == "inference":
        step_inference(args)
    elif args.step == "analyze":
        step_analyze(args)


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""
	SenseMath v2 Judge Task Inference + Analysis (J1 / J2).

	Supports both vLLM local models and OpenAI API.

	Usage:
	# vLLM inference
	python run_judge_tasks.py --step inference --task j1 --model Qwen/Qwen3-30B-A3B-Instruct-2507 --tp 4

	# OpenAI API inference
	python run_judge_tasks.py --step inference --task j1 --api --api-model gpt-5-mini --concurrency 20

	# Run paper judge tasks at once
	python run_judge_tasks.py --step inference --task all --model Qwen/Qwen3-30B-A3B-Instruct-2507 --tp 4

	# Analyze results
	python run_judge_tasks.py --step analyze
	"""

	import os
	import re
	import json
	import asyncio
	import argparse
	from pathlib import Path
	from typing import List, Dict, Optional
	from collections import defaultdict

	from dataset_registry import J1_PROFILES, load_judge_dataset, validate_existing_results

	SCRIPT_DIR = Path(__file__).parent
	V2_DATA_DIR = SCRIPT_DIR.parent / "benchmark"
	if not V2_DATA_DIR.exists():
	V2_DATA_DIR = SCRIPT_DIR.parent / "data"
	V2_RESULTS_DIR = SCRIPT_DIR.parent / "results" / "paper-aligned-v1"
	J1_PROFILE = "paper-filtered"


	# ── Helpers ───────────────────────────────────────────────────────────────────

	def safe_model_name(model: str) -> str:
	return re.sub(r"[/: ]", "_", model)


	def load_json(path: Path) -> List[Dict]:
	with open(path) as f:
	return json.load(f)


	def save_json(data, path: Path):
	path.parent.mkdir(parents=True, exist_ok=True)
	with open(path, "w") as f:
	json.dump(data, f, indent=2, ensure_ascii=False)


	def extract_yes_no(response: str) -> str:
	"""Extract YES/NO from a J1 response."""
	text = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
	# Look for explicit YES/NO (case-insensitive)
	m = re.search(r"\b(YES\|NO)\b", text, re.IGNORECASE)
	if m:
	return m.group(1).upper()
	return ""


	def extract_strategy(response: str) -> str:
	"""Extract SHORTCUT/COMPUTATION from a J2 strategy response."""
	text = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
	m = re.search(r"\b(SHORTCUT\|COMPUTATION)\b", text, re.IGNORECASE)
	if m:
	return m.group(1).upper()
	return ""


	def result_path(task: str, model_name: str) -> Path:
	scope = f"j1_{J1_PROFILE}" if task == "j1" else task
	return V2_RESULTS_DIR / f"judge_{scope}_{safe_model_name(model_name)}.json"


	def build_record(item: Dict, task: str, model: str, raw_response: str, token_count: int,
	dataset: Optional[Dict] = None) -> Dict:
	"""Build a result record from a judge item and its response."""
	rec = {
	"task_id": item["task_id"],
	"task_type": item["task_type"],
	"category": item["category"],
	"model": model,
	"prompt": item["prompt"],
	"raw_response": raw_response,
	"response_token_count": token_count,
	}
	if dataset is not None:
	rec["dataset"] = dataset

	# Variant metadata is present in both public judge tasks.
	if "variant" in item:
	rec["variant"] = item["variant"]

	# Ground truth field differs by task
	if task == "j1":
	rec["ground_truth"] = item["ground_truth"]
	rec["predicted"] = extract_yes_no(raw_response)
	elif task == "j2":
	rec["ground_truth"] = item["ground_truth"]
	rec["predicted"] = extract_strategy(raw_response)
	rec["is_correct"] = rec["predicted"] == rec["ground_truth"]
	if "source_condition" in item:
	rec["source_condition"] = item["source_condition"]
	if "source_description" in item:
	rec["source_description"] = item["source_description"]

	return rec


	# ── vLLM inference ────────────────────────────────────────────────────────────

	def run_vllm_inference(args, task: str):
	from vllm import LLM, SamplingParams
	from transformers import AutoTokenizer

	model = args.model
	model_safe = safe_model_name(model)
	V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

	# Load dataset
	items, dataset = load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE)
	print(f"Loaded {len(items)} items: {dataset['task_key']}")

	# Load existing results for resumption
	out_path = result_path(task, model)
	existing = load_json(out_path) if out_path.exists() else []
	validate_existing_results(existing, items, dataset)
	done_ids = {r["task_id"] for r in existing}

	# Filter to pending items
	pending = [it for it in items if it["task_id"] not in done_ids]
	if not pending:
	print(f"All {task.upper()} items already done for {model}.")
	return
	print(f"Pending: {len(pending)} / {len(items)}")

	# Load tokenizer for chat template
	tok = AutoTokenizer.from_pretrained(
	model, trust_remote_code=True,
	cache_dir=os.environ.get("HF_HOME"),
	)
	chat = hasattr(tok, "chat_template") and tok.chat_template
	is_thinking_model = "enable_thinking" in (tok.chat_template or "")

	def apply_template(prompt: str) -> str:
	if chat:
	messages = [{"role": "user", "content": prompt}]
	try:
	kwargs = dict(tokenize=False, add_generation_prompt=True)
	if is_thinking_model:
	kwargs["enable_thinking"] = False
	return tok.apply_chat_template(messages, **kwargs)
	except Exception:
	pass
	return prompt

	# Build prompts
	prompts = [apply_template(it["prompt"]) for it in pending]

	# Load vLLM
	llm_kwargs = dict(
	model=model, dtype="bfloat16",
	tensor_parallel_size=args.tp,
	gpu_memory_utilization=args.gpu_mem,
	trust_remote_code=True,
	max_model_len=2048,
	)
	if os.environ.get("HF_HOME"):
	llm_kwargs["download_dir"] = os.environ["HF_HOME"]

	print("Loading vLLM model...")
	llm = LLM(**llm_kwargs)
	sp = SamplingParams(temperature=0, max_tokens=args.max_tokens, seed=42)

	print(f"Running batch inference on {len(prompts)} prompts...")
	outputs = llm.generate(prompts, sp)

	new_records = []
	for out, item in zip(outputs, pending):
	raw = out.outputs[0].text.strip()
	tok_count = len(out.outputs[0].token_ids)
	rec = build_record(item, task, model, raw, tok_count, dataset)
	new_records.append(rec)

	all_records = existing + new_records
	save_json(all_records, out_path)
	print(f"Saved {len(all_records)} records -> {out_path}")


	# ── API inference ─────────────────────────────────────────────────────────────

	async def call_openai(client, model: str, prompt: str, max_tokens: int,
	semaphore: asyncio.Semaphore):
	"""Make a single OpenAI chat completion call with concurrency control."""
	async with semaphore:
	try:
	kwargs = dict(
	model=model,
	messages=[{"role": "user", "content": prompt}],
	max_completion_tokens=max_tokens,
	)
	# Some models don't support temperature=0
	if "5-mini" not in model and "o1" not in model and "o3" not in model and "o4" not in model:
	kwargs["temperature"] = 0
	response = await client.chat.completions.create(**kwargs)
	text = response.choices[0].message.content or ""
	token_count = response.usage.completion_tokens if response.usage else 0
	return text.strip(), token_count
	except Exception as e:
	print(f" API error: {e}")
	return "", 0


	async def run_api_inference_async(args, task: str):
	from openai import AsyncOpenAI

	api_key = os.environ.get("OPENAI_API_KEY")
	if not api_key:
	print("Error: OPENAI_API_KEY environment variable is not set.")
	return

	model = args.api_model
	model_safe = safe_model_name(model)
	V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

	# Load dataset
	items, dataset = load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE)
	print(f"Loaded {len(items)} items: {dataset['task_key']}")

	# Load existing results for resumption
	out_path = result_path(task, model)
	existing = load_json(out_path) if out_path.exists() else []
	validate_existing_results(existing, items, dataset)
	done_ids = {r["task_id"] for r in existing}

	pending = [it for it in items if it["task_id"] not in done_ids]
	if not pending:
	print(f"All {task.upper()} items already done for {model}.")
	return
	print(f"Pending: {len(pending)} / {len(items)}")

	client = AsyncOpenAI(api_key=api_key)
	semaphore = asyncio.Semaphore(args.concurrency)

	async_tasks = [
	call_openai(client, model, it["prompt"], args.max_tokens, semaphore)
	for it in pending
	]

	print(f"Running {len(async_tasks)} API calls with concurrency={args.concurrency}...")
	results = await asyncio.gather(*async_tasks)

	new_records = []
	for item, (response_text, token_count) in zip(pending, results):
	rec = build_record(item, task, model, response_text, token_count, dataset)
	new_records.append(rec)

	all_records = existing + new_records
	save_json(all_records, out_path)
	print(f"Saved {len(all_records)} records -> {out_path}")

	await client.close()


	def run_api_inference(args, task: str):
	asyncio.run(run_api_inference_async(args, task))


	# ── Inference dispatcher ──────────────────────────────────────────────────────

	def step_inference(args):
	tasks = ["j1", "j2"] if args.task == "all" else [args.task]

	for task in tasks:
	print(f"\n{'='*60}")
	print(f" Judge task: {task.upper()}")
	print(f"{'='*60}")

	if args.api:
	run_api_inference(args, task)
	else:
	run_vllm_inference(args, task)


	# ── Analysis ──────────────────────────────────────────────────────────────────

	def step_analyze(args):
	V2_RESULTS_DIR.mkdir(parents=True, exist_ok=True)

	# Discover all judge result files
	j1_files = sorted(V2_RESULTS_DIR.glob(f"judge_j1_{J1_PROFILE}_*.json"))
	j2_files = sorted(V2_RESULTS_DIR.glob("judge_j2_*.json"))

	if not j1_files and not j2_files:
	print("No judge result files found.")
	return

	print(f"\n{'='*80}")
	print(f" SenseMath v2 Judge Task Analysis")
	print(f"{'='*80}")

	summary = {}
	selected = {task: load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE) for task in ("j1", "j2")}

	# ── J1 Analysis (YES/NO accuracy) ────────────────────────────────────
	if j1_files:
	print(f"\n--- J1: Strategy Appropriateness (YES/NO) ---")
	print(f" {'Model':<35} {'N':>5} {'Acc%':>7} \| "
	f"{'strong':>7} {'weak':>7} {'control':>7}")
	print(f" {'-'*80}")

	for fpath in j1_files:
	records = load_json(fpath)
	validate_existing_results(records, *selected["j1"])
	if not records:
	continue
	model = records[0]["model"]
	model_short = model.split("/")[-1][:33]

	unlabeled = sum(r.get("ground_truth") is None for r in records)
	records = [r for r in records if r.get("ground_truth") is not None]
	total = len(records)
	correct = sum(1 for r in records if r.get("predicted") == r.get("ground_truth"))
	acc = correct / total if total else 0

	# Per-variant accuracy
	variant_acc = {}
	for var in ("strong_shortcut", "weak_shortcut", "control"):
	var_recs = [r for r in records if r.get("variant") == var]
	if var_recs:
	va = sum(1 for r in var_recs if r.get("predicted") == r.get("ground_truth")) / len(var_recs)
	variant_acc[var] = va
	else:
	variant_acc[var] = float("nan")

	print(f" {model_short:<35} {total:>5} {acc:>6.1%} \| "
	f"{variant_acc.get('strong_shortcut', 0):>6.1%} "
	f"{variant_acc.get('weak_shortcut', 0):>6.1%} "
	f"{variant_acc.get('control', 0):>6.1%}")

	# Per-category breakdown
	categories = sorted(set(r["category"] for r in records))
	cat_detail = {}
	for cat in categories:
	cat_recs = [r for r in records if r["category"] == cat]
	cat_acc = sum(1 for r in cat_recs if r.get("predicted") == r.get("ground_truth")) / len(cat_recs)
	cat_detail[cat] = round(cat_acc, 4)

	summary[f"J1\|{safe_model_name(model)}"] = {
	"model": model, "task": "J1", "n": total, "unlabeled": unlabeled,
	"accuracy": round(acc, 4),
	"variant_accuracy": {k: round(v, 4) for k, v in variant_acc.items()},
	"category_accuracy": cat_detail,
	}

	# Detailed per-category table
	print(f"\n J1 per-category breakdown:")
	for fpath in j1_files:
	records = [r for r in load_json(fpath) if r.get("ground_truth") is not None]
	if not records:
	continue
	model_short = records[0]["model"].split("/")[-1][:25]
	categories = sorted(set(r["category"] for r in records))
	print(f" {model_short}:")
	for cat in categories:
	cat_recs = [r for r in records if r["category"] == cat]
	cat_acc = sum(1 for r in cat_recs if r.get("predicted") == r.get("ground_truth")) / len(cat_recs)
	print(f" {cat:<30} {len(cat_recs):>4} items {cat_acc:>6.1%}")

	# ── J2 Analysis (strategy identification accuracy) ───────────────────
	if j2_files:
	print(f"\n--- J2: Strategy Identification (SHORTCUT/COMPUTATION) ---")
	print(f" {'Model':<35} {'N':>5} {'Acc%':>7} \| "
	f"{'SHORT':>7} {'COMP':>7}")
	print(f" {'-'*70}")

	for fpath in j2_files:
	records = load_json(fpath)
	validate_existing_results(records, *selected["j2"])
	if not records:
	continue
	model = records[0]["model"]
	model_short = model.split("/")[-1][:33]
	aligned = [r for r in records if "ground_truth" in r]
	n = len(aligned)
	correct = sum(1 for r in aligned if r.get("predicted") == r.get("ground_truth"))
	acc = correct / n if n else 0

	class_acc = {}
	for label in ("SHORTCUT", "COMPUTATION"):
	label_recs = [r for r in aligned if r.get("ground_truth") == label]
	class_acc[label] = (
	sum(1 for r in label_recs if r.get("predicted") == label) / len(label_recs)
	if label_recs else float("nan")
	)

	print(f" {model_short:<35} {n:>5} {acc:>6.1%} \| "
	f"{class_acc.get('SHORTCUT', 0):>6.1%} "
	f"{class_acc.get('COMPUTATION', 0):>6.1%}")

	summary[f"J2\|{safe_model_name(model)}"] = {
	"model": model, "task": "J2", "n": n,
	"accuracy": round(acc, 4),
	"strategy_accuracy": {
	"SHORTCUT": round(class_acc.get("SHORTCUT", 0), 4),
	"COMPUTATION": round(class_acc.get("COMPUTATION", 0), 4),
	},
	}

	# Save summary
	out_path = V2_RESULTS_DIR / f"judge_analysis_{J1_PROFILE}.json"
	save_json(summary, out_path)
	print(f"\nSaved analysis -> {out_path}")


	# ── Main ──────────────────────────────────────────────────────────────────────

	def main():
	global V2_DATA_DIR, V2_RESULTS_DIR, J1_PROFILE
	parser = argparse.ArgumentParser(
	description="SenseMath v2 Judge Task Inference + Analysis (J1/J2)")

	parser.add_argument("--step", required=True,
	choices=["inference", "analyze", "validate"])
	parser.add_argument("--task", default="all",
	choices=["j1", "j2", "all"],
	help="Which judge task to run. all runs paper J1/J2.")
	parser.add_argument("--data-dir", type=Path, default=V2_DATA_DIR,
	help="Directory containing the shared dataset manifest (benchmark/ or HF data/).")
	parser.add_argument("--j1-profile", choices=list(J1_PROFILES), default="paper-filtered",
	help="J1 full 300-item set or paper-filtered 261-item subset; never pooled.")

	# vLLM options
	parser.add_argument("--model", default="Qwen/Qwen3-30B-A3B-Instruct-2507",
	help="HuggingFace model for vLLM")
	parser.add_argument("--tp", type=int, default=1,
	help="Tensor parallel size for vLLM")
	parser.add_argument("--gpu-mem", type=float, default=0.90,
	help="GPU memory utilization for vLLM")

	# API options
	parser.add_argument("--api", action="store_true",
	help="Use OpenAI API instead of vLLM")
	parser.add_argument("--api-model", default="gpt-5-mini",
	help="OpenAI model name (used with --api)")
	parser.add_argument("--concurrency", type=int, default=20,
	help="Max concurrent API requests")

	# Shared
	parser.add_argument("--max-tokens", type=int, default=512,
	help="Max tokens for generation")

	args = parser.parse_args()
	V2_DATA_DIR = args.data_dir
	J1_PROFILE = args.j1_profile
	manifest = load_json(V2_DATA_DIR / "manifest.json")
	V2_RESULTS_DIR = SCRIPT_DIR.parent / "results" / manifest["release_id"]

	if args.step == "validate":
	for task in (["j1", "j2"] if args.task == "all" else [args.task]):
	_, metadata = load_judge_dataset(V2_DATA_DIR, task, J1_PROFILE)
	print(json.dumps(metadata, sort_keys=True))
	elif args.step == "inference":
	step_inference(args)
	elif args.step == "analyze":
	step_analyze(args)


	if __name__ == "__main__":
	main()