Download scripts/evaluator.py from AnonymousORG01/QASM-Eval: direct link, hf CLI and curl.
- Browser
- Download file 10 kB
-
https://huggingface.co/datasets/AnonymousORG01/QASM-Eval/resolve/main/scripts/evaluator.py
- Command line
-
hf download hf://datasets/AnonymousORG01/QASM-Eval/scripts/evaluator.py
-
curl -L -o evaluator.py https://huggingface.co/datasets/AnonymousORG01/QASM-Eval/resolve/main/scripts/evaluator.py
10 kB
| from __future__ import annotations | |
| import os | |
| import re | |
| import sys | |
| from dataclasses import asdict, dataclass | |
| from typing import Any, Callable, TypeVar | |
| #============================================================================== | |
| # IMPORTANT: | |
| # either set enough shots (recommend 8000) or set a fixed random seed. | |
| # the random nature of quantum simulation means that with too few shots, even a correct program may fail the check. | |
| #============================================================================== | |
| START_RE = re.compile(r"^\s*//\s*===\s*CORE_TASK_START\s*===.*$", re.IGNORECASE | re.MULTILINE) | |
| END_RE = re.compile(r"^\s*//\s*===\s*CORE_TASK_END\s*===.*$", re.IGNORECASE | re.MULTILINE) | |
| _T = TypeVar("_T") | |
| SEED_DIST = 12345 | |
| SEED_TIMELINE = 67890 | |
| class EvaluationResult: | |
| ok: bool | |
| syntax_ok: bool | None | |
| element_ok: bool | None | |
| dist_ok: bool | None | |
| timeline_ok: bool | None | |
| tvd: float | None = None | |
| timeline_dist: float | None = None | |
| detail: str | None = None | |
| candidate_qasm: str | None = None | |
| cleaned_returned_code: str | None = None | |
| def to_dict(self) -> dict[str, Any]: | |
| return asdict(self) | |
| def _ensure_scripts_dir_on_path() -> None: | |
| scripts_dir = os.path.dirname(os.path.abspath(__file__)) | |
| if scripts_dir not in sys.path: | |
| sys.path.insert(0, scripts_dir) | |
| def _import_judge(): | |
| _ensure_scripts_dir_on_path() | |
| try: | |
| from scripts import judge | |
| except Exception: | |
| import judge | |
| return judge | |
| def _with_numpy_seed(seed: int, func: Callable[[], _T]) -> _T: | |
| try: | |
| import numpy as np | |
| except Exception: | |
| return func() | |
| state = np.random.get_state() | |
| try: | |
| np.random.seed(seed) | |
| return func() | |
| finally: | |
| np.random.set_state(state) | |
| def clean_returned_code(text: str) -> str: | |
| text = (text or "").strip() | |
| if text.startswith("```"): | |
| text = re.sub(r"^```[a-zA-Z0-9_-]*\s*", "", text) | |
| text = re.sub(r"\s*```$", "", text) | |
| lines: list[str] = [] | |
| for line in text.splitlines(): | |
| if START_RE.match(line) or END_RE.match(line): | |
| continue | |
| lines.append(line.rstrip()) | |
| return "\n".join(lines).strip("\n\r") | |
| def _detect_newline(text: str) -> str: | |
| if "\r\n" in text: | |
| return "\r\n" | |
| return "\n" | |
| def extract_core_block(qasm: str) -> str: | |
| start = START_RE.search(qasm) | |
| if not start: | |
| raise ValueError("CORE_TASK_START not found") | |
| end = END_RE.search(qasm, pos=start.end()) | |
| if not end: | |
| raise ValueError("CORE_TASK_END not found") | |
| return qasm[start.end():end.start()].strip("\n\r") | |
| def replace_core_block(qasm: str, core_snippet: str) -> str: | |
| start = START_RE.search(qasm) | |
| if not start: | |
| raise ValueError("CORE_TASK_START not found") | |
| end = END_RE.search(qasm, pos=start.end()) | |
| if not end: | |
| raise ValueError("CORE_TASK_END not found") | |
| newline = _detect_newline(qasm) | |
| core_snippet = core_snippet.strip("\n\r") | |
| middle = newline + core_snippet + newline if core_snippet else newline | |
| return qasm[:start.end()] + middle + qasm[end.start():] | |
| def returned_code_to_qasm(golden_code: str, returned_code: str) -> tuple[str, str]: | |
| if re.search(r"^\s*OPENQASM\s+3\s*;", returned_code or "", flags=re.IGNORECASE | re.MULTILINE): | |
| candidate_qasm = returned_code.strip() + "\n" | |
| try: | |
| cleaned = clean_returned_code(extract_core_block(candidate_qasm)) | |
| except ValueError: | |
| cleaned = clean_returned_code(returned_code) | |
| return candidate_qasm, cleaned | |
| cleaned = clean_returned_code(returned_code) | |
| return replace_core_block(golden_code, cleaned), cleaned | |
| def infer_domain(golden_code: str, default: str = "complex") -> str: | |
| lowered = golden_code.lower() | |
| if "delay[" in lowered or "durationof" in lowered: | |
| return "timing" | |
| if "defcal" in lowered or "cal {" in lowered or "play(" in lowered: | |
| return "pulse" | |
| if any(token in lowered for token in ("while", "if (", "for ", "switch", "extern ")): | |
| return "complex" | |
| return default | |
| def evaluate_qasm_completion( | |
| golden_code: str, | |
| returned_code: str, | |
| domain: str | None = None, | |
| require_distribution: bool | None = None, | |
| require_timeline: bool | None = None, | |
| ) -> EvaluationResult: | |
| """Evaluate one QASM answer against a golden program. | |
| Args: | |
| golden_code: The canonical full QASM program. If `returned_code` is a | |
| snippet, `golden_code` must contain the CORE_TASK markers. | |
| returned_code: Either a full OpenQASM program or only the completed core | |
| snippet returned by a model. | |
| domain: One of `timing`, `classical`, `pulse`, or `complex`. When | |
| omitted, a conservative best-effort inference is used. | |
| require_distribution: Override the final `ok` decision to require a | |
| correct distribution result. | |
| require_timeline: Override the final `ok` decision to require a correct | |
| timeline result. | |
| Returns: | |
| EvaluationResult. `ok` follows the same domain-specific policy as | |
| `scripts/judge.py`: timing checks timeline, classical/pulse check | |
| distribution, and complex checks both. | |
| """ | |
| try: | |
| candidate_qasm, cleaned = returned_code_to_qasm(golden_code, returned_code) | |
| except Exception as exc: | |
| return EvaluationResult( | |
| ok=False, | |
| syntax_ok=None, | |
| element_ok=None, | |
| dist_ok=None, | |
| timeline_ok=None, | |
| detail=f"preprocess failed: {exc}", | |
| cleaned_returned_code=clean_returned_code(returned_code), | |
| ) | |
| task_type = domain or infer_domain(golden_code) | |
| try: | |
| judge = _import_judge() | |
| except Exception as exc: | |
| return EvaluationResult( | |
| ok=False, | |
| syntax_ok=None, | |
| element_ok=None, | |
| dist_ok=None, | |
| timeline_ok=None, | |
| detail=f"semantic judge unavailable: {exc}", | |
| candidate_qasm=candidate_qasm, | |
| cleaned_returned_code=cleaned, | |
| ) | |
| try: | |
| golden_program = judge.parse_qasm_safely(golden_code) | |
| golden_exist = judge.extract_exist_from_program(golden_program) | |
| golden_dist = _with_numpy_seed( | |
| SEED_DIST, | |
| lambda: judge.simulate_distribution_safely(golden_code, shots=judge.SHOTS_DIST_GOLDEN), | |
| ) | |
| golden_timeline_text = _with_numpy_seed( | |
| SEED_TIMELINE, | |
| lambda: judge.simulate_timeline_text_safely(golden_code), | |
| ) | |
| golden_events = judge.parse_timeline_events(golden_timeline_text) | |
| try: | |
| candidate_program = judge.parse_qasm_safely(candidate_qasm) | |
| except Exception as exc: | |
| return EvaluationResult( | |
| ok=False, | |
| syntax_ok=False, | |
| element_ok=False, | |
| dist_ok=None, | |
| timeline_ok=None, | |
| detail=f"syntax parse failed: {exc}", | |
| candidate_qasm=candidate_qasm, | |
| cleaned_returned_code=cleaned, | |
| ) | |
| candidate_exist = judge.extract_exist_from_program(candidate_program) | |
| missing = [k for k, v in golden_exist.items() if v and not candidate_exist.get(k, False)] | |
| if missing: | |
| return EvaluationResult( | |
| ok=False, | |
| syntax_ok=True, | |
| element_ok=False, | |
| dist_ok=None, | |
| timeline_ok=None, | |
| detail=f"exist missing: {missing[:20]}" + (" ..." if len(missing) > 20 else ""), | |
| candidate_qasm=candidate_qasm, | |
| cleaned_returned_code=cleaned, | |
| ) | |
| candidate_dist = _with_numpy_seed( | |
| SEED_DIST, | |
| lambda: judge.simulate_distribution_safely(candidate_qasm, shots=judge.SHOTS_DIST_CAND), | |
| ) | |
| dist_err = judge.tvd(golden_dist, candidate_dist) | |
| dist_ok = dist_err <= judge.dist_tol_for_task(task_type) | |
| candidate_timeline_text = _with_numpy_seed( | |
| SEED_TIMELINE, | |
| lambda: judge.simulate_timeline_text_safely(candidate_qasm), | |
| ) | |
| candidate_events = judge.parse_timeline_events(candidate_timeline_text) | |
| timeline_dist = judge.timeline_distance_normalized(golden_events, candidate_events) | |
| timeline_ok = judge.timeline_ok_for_task(task_type, golden_events, candidate_events) | |
| ok = judge.decide_ok(task_type, True, True, dist_ok, timeline_ok) | |
| if require_distribution is not None or require_timeline is not None: | |
| required: list[bool] = [True, True] | |
| if require_distribution: | |
| required.append(bool(dist_ok)) | |
| if require_timeline: | |
| required.append(bool(timeline_ok)) | |
| ok = all(required) | |
| except Exception as exc: | |
| return EvaluationResult( | |
| ok=False, | |
| syntax_ok=None, | |
| element_ok=None, | |
| dist_ok=None, | |
| timeline_ok=None, | |
| detail=f"semantic judge failed: {exc}", | |
| candidate_qasm=candidate_qasm, | |
| cleaned_returned_code=cleaned, | |
| ) | |
| return EvaluationResult( | |
| ok=bool(ok), | |
| syntax_ok=True, | |
| element_ok=True, | |
| dist_ok=dist_ok, | |
| timeline_ok=timeline_ok, | |
| tvd=dist_err, | |
| timeline_dist=timeline_dist, | |
| detail=None, | |
| candidate_qasm=candidate_qasm, | |
| cleaned_returned_code=cleaned, | |
| ) | |
| def check(golden_code: str, returned_code: str, domain: str | None = None) -> bool: | |
| return evaluate_qasm_completion(golden_code, returned_code, domain=domain).ok | |
| def check_timeline_and_distribution( | |
| golden_code: str, | |
| returned_code: str, | |
| domain: str | None = None, | |
| ) -> bool: | |
| return evaluate_qasm_completion( | |
| golden_code, | |
| returned_code, | |
| domain=domain or "complex", | |
| require_distribution=True, | |
| require_timeline=True, | |
| ).ok | |