QASM-Eval / run_test.py
AnonymousUser01's picture
Upload 5 files
efa9c3e verified
Raw History Blame Contribute Delete
8.66 kB
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import annotations
import json
import random
import sys
from datetime import datetime
from pathlib import Path
from typing import Any
if __package__ in (None, ""):
PACKAGE_ROOT = Path(__file__).resolve().parent
if str(PACKAGE_ROOT) not in sys.path:
sys.path.insert(0, str(PACKAGE_ROOT))
from dataset_factory.LLM import LLM_model
from scripts.evaluator import evaluate_qasm_completion
else:
from .dataset_factory.LLM import LLM_model
from .scripts.evaluator import evaluate_qasm_completion
# ============== CONFIGURATION ==============
TEST_DATA_PATH = "data/test.jsonl"
OUTPUT_DIR = "test_runs"
# mode: "random_sample" or "all"
RUN_MODE = "all" # or "random_sample"
NUM_RANDOM_SAMPLES = 8 # if RUN_MODE is "all", then it will select all 100 test tasks
RANDOM_SEED = 20260426
# generate k candidates per task, then compute pass@k for k = 1..PASS_AT_K
PASS_AT_K = 5
LLM_CHOICE = "openai/gpt-oss-120b" # the model to be tested
LLM_PROVIDER = "nebius"
LLM_KEY='YOUR OWN KEY HERE'
LLM_TEMPERATURE = 0.7
LLM_MAX_TOKENS = 1200
SYSTEM_PROMPT = (
"You complete missing QASM core blocks.\n"
"Output only the QASM statements that belong between CORE_TASK_START and CORE_TASK_END. Do\n"
"not output the markers themselves. Do not output explanations. Do not use backticks."
)
# ============== CONFIGURATION END ==============
def load_jsonl(path: Path) -> list[dict[str, Any]]:
records: list[dict[str, Any]] = []
with path.open("r", encoding="utf-8") as handle:
for line in handle:
line = line.strip()
if line:
records.append(json.loads(line))
return records
def select_records(records: list[dict[str, Any]]) -> list[dict[str, Any]]:
if RUN_MODE == "all":
return list(records)
if RUN_MODE != "random_sample":
raise ValueError(f"Unsupported RUN_MODE: {RUN_MODE}")
sample_size = min(NUM_RANDOM_SAMPLES, len(records))
rng = random.Random(RANDOM_SEED)
return rng.sample(records, sample_size)
def compute_pass_at_k(per_task_ok_by_k: dict[str, dict[int, bool]], k_max: int) -> dict[int, float]:
task_ids = sorted(per_task_ok_by_k.keys())
if not task_ids:
return {k: 0.0 for k in range(1, k_max + 1)}
pass_at_k: dict[int, float] = {}
for k_value in range(1, k_max + 1):
passed = 0
for task_id in task_ids:
ok_map = per_task_ok_by_k.get(task_id, {})
hit = any(ok for idx, ok in ok_map.items() if idx <= k_value)
if hit:
passed += 1
pass_at_k[k_value] = passed / len(task_ids)
return pass_at_k
def build_output_paths(root_dir: Path) -> tuple[Path, Path]:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
run_dir = root_dir / f"run_{timestamp}"
run_dir.mkdir(parents=True, exist_ok=True)
return run_dir / "summary.json", run_dir / "details.jsonl"
def write_json(path: Path, payload: dict[str, Any]) -> None:
path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
with path.open("w", encoding="utf-8") as handle:
for row in rows:
handle.write(json.dumps(row, ensure_ascii=False) + "\n")
def build_user_prompt(prompt_qasm: str) -> str:
return (
"Here is a QASM program with a missing core block. Fill in the missing core block.\n"
"Return only the missing core QASM statements.\n"
"––- BEGIN PROGRAM ––-\n"
f"{prompt_qasm}\n"
"––- END PROGRAM ––-"
)
def main() -> dict[str, Any]:
root = Path(__file__).resolve().parent
test_data_path = root / TEST_DATA_PATH
output_root = root / OUTPUT_DIR
output_root.mkdir(parents=True, exist_ok=True)
records = load_jsonl(test_data_path)
selected_records = select_records(records)
summary_path, details_path = build_output_paths(output_root)
client = LLM_model(
llm_choice=LLM_CHOICE,
llm_key=LLM_KEY,
temp=LLM_TEMPERATURE,
provider=LLM_PROVIDER,
)
per_task_ok_by_k: dict[str, dict[int, bool]] = {}
details: list[dict[str, Any]] = []
domain_counts: dict[str, int] = {}
domain_pass_counts_by_k: dict[str, dict[int, int]] = {}
for task_idx, record in enumerate(selected_records, start=1):
task_id = record["task_id"]
domain = record["domain"]
prompt = record["prompt"]
golden_code = record["canonical_solution"]
domain_counts[domain] = domain_counts.get(domain, 0) + 1
per_task_ok_by_k[task_id] = {}
print(f"[task {task_idx}/{len(selected_records)}] {task_id} | domain={domain}")
for k_idx in range(1, PASS_AT_K + 1):
response = client.generate(
prompt=build_user_prompt(prompt),
system_prompt=SYSTEM_PROMPT,
max_tokens=LLM_MAX_TOKENS,
)
result = evaluate_qasm_completion(
golden_code=golden_code,
returned_code=response,
domain=domain,
)
evaluation = result.to_dict()
per_task_ok_by_k[task_id][k_idx] = bool(result.ok)
details.append(
{
"task_id": task_id,
"domain": domain,
"sample_index": k_idx,
"model": LLM_CHOICE,
"provider": LLM_PROVIDER,
"response": response,
"evaluation": evaluation,
}
)
print(
f" - sample {k_idx}/{PASS_AT_K}: "
f"ok={result.ok}, "
f"syntax_ok={result.syntax_ok}, "
f"element_ok={result.element_ok}, "
f"dist_ok={result.dist_ok}, "
f"timeline_ok={result.timeline_ok}"
)
overall_pass_at_k = compute_pass_at_k(per_task_ok_by_k, PASS_AT_K)
for domain, count in domain_counts.items():
domain_task_ids = [
record["task_id"] for record in selected_records if record["domain"] == domain
]
domain_ok_map = {task_id: per_task_ok_by_k[task_id] for task_id in domain_task_ids}
domain_pass_values = compute_pass_at_k(domain_ok_map, PASS_AT_K)
domain_pass_counts_by_k[domain] = {
k_value: int(round(domain_pass_values[k_value] * count)) for k_value in domain_pass_values
}
summary = {
"config": {
"test_data_path": str(test_data_path),
"output_dir": str(output_root),
"run_mode": RUN_MODE,
"num_random_samples": NUM_RANDOM_SAMPLES,
"random_seed": RANDOM_SEED,
"pass_at_k": PASS_AT_K,
"llm_choice": LLM_CHOICE,
"llm_provider": LLM_PROVIDER,
"llm_temperature": LLM_TEMPERATURE,
"llm_max_tokens": LLM_MAX_TOKENS,
"selected_task_count": len(selected_records),
"total_available_task_count": len(records),
},
"overall": {
"task_count": len(selected_records),
"pass_at_k": {str(k): v for k, v in overall_pass_at_k.items()},
},
"by_domain": {},
"token_usage": {
"prompt_tokens": client.total_prompt_tokens,
"completion_tokens": client.total_completion_tokens,
"total_tokens": client.total_tokens,
},
"artifacts": {
"summary_json": str(summary_path),
"details_jsonl": str(details_path),
},
}
for domain, count in sorted(domain_counts.items()):
domain_task_ids = [
record["task_id"] for record in selected_records if record["domain"] == domain
]
domain_ok_map = {task_id: per_task_ok_by_k[task_id] for task_id in domain_task_ids}
domain_pass_at_k = compute_pass_at_k(domain_ok_map, PASS_AT_K)
summary["by_domain"][domain] = {
"task_count": count,
"pass_at_k": {str(k): v for k, v in domain_pass_at_k.items()},
}
write_json(summary_path, summary)
write_jsonl(details_path, details)
print("")
print("=== Summary ===")
print(f"selected tasks: {len(selected_records)} / {len(records)}")
for k_value in range(1, PASS_AT_K + 1):
print(f"pass@{k_value}: {overall_pass_at_k[k_value]:.4f}")
print(f"summary saved to: {summary_path}")
print(f"details saved to: {details_path}")
return summary
if __name__ == "__main__":
main()