qcoder 0.1.0a0__py3-none-any.whl

qcoder/tools/predict_baseline.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from qcoder.engines.feature_extraction.extractor import extract_example
+
+
+DEFAULT_RUNTIME_ARTIFACT = Path("data/artifacts/models/qr12/schema_0.4.0/runtime_ridge.json")
+DEFAULT_BUILD_ARTIFACT = Path("data/artifacts/models/qr12/schema_0.4.0/build_ridge.json")
+DEFAULT_FIDELITY_ARTIFACT = Path("data/artifacts/models/qr12/schema_0.4.0/fidelity_ridge.json")
+DEFAULT_MEMORY_ARTIFACT = Path("data/artifacts/models/qr12/schema_0.4.0/memory_ridge.json")
+DEFAULT_LADDER = [2, 4, 8, 16, 32, 64]
+DEFAULT_SHOTS_TOTAL = 10000
+
+
+@dataclass(frozen=True)
+class RidgeArtifact:
+    schema_version: str
+    feature_names: list[str]
+    coef: list[float]
+    x_mean: list[float]
+    x_std: list[float]
+    alpha: float
+
+
+def _parse_ladder(text: str) -> list[int]:
+    out: list[int] = []
+    for part in (text or "").split(","):
+        s = part.strip()
+        if not s:
+            continue
+        v = int(s)
+        if v <= 0:
+            raise ValueError(f"ladder threshold must be > 0, got {v}")
+        out.append(v)
+    if not out:
+        raise ValueError("empty ladder")
+    return out
+
+
+def load_ridge_artifact(path: str | Path) -> RidgeArtifact:
+    p = Path(path)
+    try:
+        raw = p.read_text(encoding="utf-8")
+    except FileNotFoundError as e:
+        raise FileNotFoundError(
+            f"ridge artifact not found: {p.resolve()} "
+            "(train models with qcoder.tools.train_baseline_models or pass explicit artifact paths)"
+        ) from e
+    data = json.loads(raw)
+
+    schema_version = data.get("schema_version")
+    feature_names = data.get("feature_names")
+    coef = data.get("coef")
+    x_mean = data.get("x_mean")
+    x_std = data.get("x_std")
+    alpha = data.get("alpha", 1.0)
+
+    if not isinstance(schema_version, str) or not schema_version:
+        raise ValueError(f"invalid artifact schema_version: {path}")
+    if not isinstance(feature_names, list) or not feature_names:
+        raise ValueError(f"invalid artifact feature_names: {path}")
+    if not isinstance(coef, list) or not isinstance(x_mean, list) or not isinstance(x_std, list):
+        raise ValueError(f"invalid artifact vectors: {path}")
+
+    n = len(feature_names)
+    if len(coef) != n or len(x_mean) != n or len(x_std) != n:
+        raise ValueError(f"artifact vector length mismatch in {path}")
+
+    coef_f = [float(v) for v in coef]
+    mean_f = [float(v) for v in x_mean]
+    std_f = [1.0 if float(v) == 0.0 else float(v) for v in x_std]
+
+    return RidgeArtifact(
+        schema_version=schema_version,
+        feature_names=[str(nm) for nm in feature_names],
+        coef=coef_f,
+        x_mean=mean_f,
+        x_std=std_f,
+        alpha=float(alpha),
+    )
+
+
+def _build_input_vector(
+    artifact: RidgeArtifact,
+    *,
+    feature_map: dict[str, float],
+    threshold: int,
+    precision: str,
+    shots_total: int | None = None,
+) -> list[float]:
+    precision_is_double = 1.0 if str(precision).strip().lower() in {"double", "fp64"} else 0.0
+    cond: dict[str, float] = {
+        "bias": 1.0,
+        "log2_threshold": math.log2(float(threshold)),
+        "precision_is_double": precision_is_double,
+    }
+    if "log2_shots_runner" in artifact.feature_names:
+        cond["log2_shots_runner"] = math.log2(max(1, shots_total if shots_total is not None else DEFAULT_SHOTS_TOTAL))
+    x: list[float] = []
+    for name in artifact.feature_names:
+        if name in cond:
+            x.append(cond[name])
+            continue
+        if name not in feature_map:
+            raise ValueError(f"artifact expects missing feature '{name}'")
+        x.append(float(feature_map[name]))
+    return x
+
+
+def _predict_linear(artifact: RidgeArtifact, x: list[float]) -> float:
+    if len(x) != len(artifact.coef):
+        raise ValueError("input vector length mismatch")
+    total = 0.0
+    for i, v in enumerate(x):
+        z = (float(v) - artifact.x_mean[i]) / artifact.x_std[i]
+        total += artifact.coef[i] * z
+    return total
+
+
+def _sigmoid(x: float) -> float:
+    if x >= 0:
+        e = math.exp(-x)
+        return 1.0 / (1.0 + e)
+    e = math.exp(x)
+    return e / (1.0 + e)
+
+
+def predict_threshold_table(
+    *,
+    qasm_path: str,
+    runtime_artifact_path: str | Path = DEFAULT_RUNTIME_ARTIFACT,
+    build_artifact_path: str | Path | None = None,
+    memory_artifact_path: str | Path | None = None,
+    fidelity_artifact_path: str | Path = DEFAULT_FIDELITY_ARTIFACT,
+    ladder: list[int] | None = None,
+    precision: str = "double",
+    shots_total: int | None = None,
+) -> dict[str, Any]:
+    ex = extract_example(qasm_path)
+    fv = ex.global_features
+    feature_map = dict(zip(fv.feature_names, fv.features))
+
+    runtime_art = load_ridge_artifact(runtime_artifact_path)
+    build_art = load_ridge_artifact(build_artifact_path) if build_artifact_path is not None else None
+    memory_art = load_ridge_artifact(memory_artifact_path) if memory_artifact_path is not None else None
+    fidelity_art = load_ridge_artifact(fidelity_artifact_path)
+
+    if runtime_art.schema_version != fv.schema_version:
+        raise ValueError(
+            f"runtime artifact schema mismatch: features={fv.schema_version}, artifact={runtime_art.schema_version}"
+        )
+    if fidelity_art.schema_version != fv.schema_version:
+        raise ValueError(
+            f"fidelity artifact schema mismatch: features={fv.schema_version}, artifact={fidelity_art.schema_version}"
+        )
+    if build_art is not None and build_art.schema_version != fv.schema_version:
+        raise ValueError(
+            f"build artifact schema mismatch: features={fv.schema_version}, artifact={build_art.schema_version}"
+        )
+    if memory_art is not None and memory_art.schema_version != fv.schema_version:
+        raise ValueError(
+            f"memory artifact schema mismatch: features={fv.schema_version}, artifact={memory_art.schema_version}"
+        )
+
+    # Backward compatibility: runtime artifact may predict total (old) or execution time (execution_runtime_ridge).
+    runtime_artifact_data = json.loads(Path(runtime_artifact_path).read_text(encoding="utf-8"))
+    runtime_model_kind = (runtime_artifact_data.get("training_metadata") or {}).get("model_kind")
+
+    use_ladder = list(ladder or DEFAULT_LADDER)
+    shots = shots_total if shots_total is not None else DEFAULT_SHOTS_TOTAL
+    rows: list[dict[str, float | int]] = []
+    for thr in use_ladder:
+        x_rt = _build_input_vector(
+            runtime_art, feature_map=feature_map, threshold=int(thr), precision=precision, shots_total=shots
+        )
+        y_rt = _predict_linear(runtime_art, x_rt)
+        pred_build: float | None = None
+        pred_exec: float | None = None
+        pred_total: float
+        if runtime_model_kind == "execution_runtime_ridge":
+            # Runtime model predicts execution time; total = build + exec.
+            pred_exec = max(0.0, math.expm1(y_rt))
+            if build_art is not None:
+                x_bd = _build_input_vector(build_art, feature_map=feature_map, threshold=int(thr), precision=precision)
+                y_bd = _predict_linear(build_art, x_bd)
+                pred_build = max(0.0, math.expm1(y_bd))
+                pred_total = float(pred_build) + float(pred_exec)
+            else:
+                pred_total = float(pred_exec)
+        else:
+            # Legacy: runtime model predicts total runtime; exec = total - build.
+            pred_total = max(0.0, math.expm1(y_rt))
+            if build_art is not None:
+                x_bd = _build_input_vector(build_art, feature_map=feature_map, threshold=int(thr), precision=precision)
+                y_bd = _predict_linear(build_art, x_bd)
+                pred_build = max(0.0, math.expm1(y_bd))
+                pred_exec = max(0.0, float(pred_total) - float(pred_build))
+
+        pred_mem_mb: float | None = None
+        if memory_art is not None:
+            x_mb = _build_input_vector(memory_art, feature_map=feature_map, threshold=int(thr), precision=precision)
+            y_mb = _predict_linear(memory_art, x_mb)
+            pred_mem_mb = max(0.0, math.expm1(y_mb))
+
+        x_fd = _build_input_vector(fidelity_art, feature_map=feature_map, threshold=int(thr), precision=precision)
+        y_fd = _predict_linear(fidelity_art, x_fd)
+        pred_fidelity = _sigmoid(y_fd)
+
+        rows.append(
+            {
+                "threshold": int(thr),
+                "predicted_total_runtime_s": float(pred_total),
+                "predicted_runtime_s": float(pred_total),  # backward-compat alias
+                "predicted_fidelity": float(pred_fidelity),
+            }
+        )
+        if pred_build is not None and pred_exec is not None:
+            rows[-1]["predicted_build_time_s"] = float(pred_build)
+            rows[-1]["predicted_exec_time_s"] = float(pred_exec)
+            rows[-1]["predicted_exec_time_per_shot_s"] = float(pred_exec) / float(shots)
+            rows[-1]["predicted_exec_time_per_1000_shots_s"] = 1000.0 * float(pred_exec) / float(shots)
+        if pred_mem_mb is not None:
+            rows[-1]["predicted_peak_mem_mb"] = float(pred_mem_mb)
+
+    return {
+        "qasm_path": str(qasm_path),
+        "schema_version": fv.schema_version,
+        "n_features": len(fv.features),
+        "precision": precision,
+        "rows": rows,
+    }
+
+
+def _recommend_threshold(rows: list[dict[str, float | int]], target_fidelity: float) -> int | None:
+    candidates = [int(r["threshold"]) for r in rows if float(r["predicted_fidelity"]) >= target_fidelity]
+    if not candidates:
+        return None
+    return min(candidates)
+
+
+def _print_table(result: dict[str, Any], target_fidelity: float | None) -> None:
+    print(f"qasm: {result['qasm_path']}")
+    print(f"schema: {result['schema_version']}  n_features: {result['n_features']}  precision: {result['precision']}")
+    print("")
+    has_build = any(("predicted_build_time_s" in r and "predicted_exec_time_s" in r) for r in result["rows"])
+    has_mem = any("predicted_peak_mem_mb" in r for r in result["rows"])
+    if has_build and has_mem:
+        print(
+            f"{'threshold':>9}  {'pred_build_time_s':>17}  {'pred_exec_time_s':>16}  {'pred_exec_per_shot_s':>18}  {'pred_exec_per_1000_s':>16}  {'pred_total_runtime_s':>20}  {'predicted_fidelity':>19}  {'pred_peak_mem_mb':>16}"
+        )
+        print("-" * 149)
+    elif has_build:
+        print(
+            f"{'threshold':>9}  {'pred_build_time_s':>17}  {'pred_exec_time_s':>16}  {'pred_exec_per_shot_s':>18}  {'pred_exec_per_1000_s':>16}  {'pred_total_runtime_s':>20}  {'predicted_fidelity':>19}"
+        )
+        print("-" * 125)
+    else:
+        print(f"{'threshold':>9}  {'pred_total_runtime_s':>20}  {'predicted_fidelity':>19}")
+        print("-" * 54)
+    for r in result["rows"]:
+        if has_build and has_mem:
+            print(
+                f"{int(r['threshold']):>9}  {float(r['predicted_build_time_s']):>17.6f}  {float(r['predicted_exec_time_s']):>16.6f}  {float(r['predicted_exec_time_per_shot_s']):>18.6e}  {float(r['predicted_exec_time_per_1000_shots_s']):>16.6f}  {float(r['predicted_total_runtime_s']):>20.6f}  {float(r['predicted_fidelity']):>19.6f}  {float(r['predicted_peak_mem_mb']):>16.3f}"
+            )
+        elif has_build:
+            print(
+                f"{int(r['threshold']):>9}  {float(r['predicted_build_time_s']):>17.6f}  {float(r['predicted_exec_time_s']):>16.6f}  {float(r['predicted_exec_time_per_shot_s']):>18.6e}  {float(r['predicted_exec_time_per_1000_shots_s']):>16.6f}  {float(r['predicted_total_runtime_s']):>20.6f}  {float(r['predicted_fidelity']):>19.6f}"
+            )
+        else:
+            print(
+                f"{int(r['threshold']):>9}  {float(r['predicted_total_runtime_s']):>20.6f}  {float(r['predicted_fidelity']):>19.6f}"
+            )
+    if target_fidelity is not None:
+        rec = _recommend_threshold(result["rows"], target_fidelity)
+        print("")
+        if rec is None:
+            print(f"recommended_threshold(target={target_fidelity:.4f}): none_meets_target")
+        else:
+            print(f"recommended_threshold(target={target_fidelity:.4f}): {rec}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Predict runtime/fidelity over a threshold ladder for one QASM.")
+    ap.add_argument("qasm", help="Path to one .qasm file")
+    ap.add_argument("--runtime-artifact", default=str(DEFAULT_RUNTIME_ARTIFACT), help="Path to runtime_ridge.json")
+    ap.add_argument(
+        "--build-artifact",
+        default=None,
+        help="Optional path to build_ridge.json. If omitted, defaults to schema build_ridge when present.",
+    )
+    ap.add_argument(
+        "--memory-artifact",
+        default=None,
+        help="Optional path to memory_ridge.json. If omitted, defaults to schema memory_ridge when present.",
+    )
+    ap.add_argument("--fidelity-artifact", default=str(DEFAULT_FIDELITY_ARTIFACT), help="Path to fidelity_ridge.json")
+    ap.add_argument("--ladder", default="2,4,8,16,32,64", help="Comma-separated threshold ladder")
+    ap.add_argument("--precision", default="double", help="single|double (used for precision_is_double)")
+    ap.add_argument("--shots-total", type=int, default=None, help="Total-run shot count for runtime prediction (default: 10000)")
+    ap.add_argument("--target-fidelity", type=float, default=None, help="Optional target fidelity for recommended threshold")
+    ap.add_argument("--json", action="store_true", help="Emit JSON instead of text table")
+    args = ap.parse_args(argv)
+
+    ladder = _parse_ladder(args.ladder)
+    build_path: str | Path | None
+    if args.build_artifact:
+        build_path = args.build_artifact
+    elif DEFAULT_BUILD_ARTIFACT.exists():
+        build_path = DEFAULT_BUILD_ARTIFACT
+    else:
+        build_path = None
+    mem_path: str | Path | None
+    if args.memory_artifact:
+        mem_path = args.memory_artifact
+    elif DEFAULT_MEMORY_ARTIFACT.exists():
+        mem_path = DEFAULT_MEMORY_ARTIFACT
+    else:
+        mem_path = None
+
+    result = predict_threshold_table(
+        qasm_path=args.qasm,
+        runtime_artifact_path=args.runtime_artifact,
+        build_artifact_path=build_path,
+        memory_artifact_path=mem_path,
+        fidelity_artifact_path=args.fidelity_artifact,
+        ladder=ladder,
+        precision=args.precision,
+        shots_total=args.shots_total,
+    )
+    if args.target_fidelity is not None:
+        result["recommended_threshold"] = _recommend_threshold(result["rows"], float(args.target_fidelity))
+
+    if args.json:
+        print(json.dumps(result, indent=2, sort_keys=True))
+    else:
+        _print_table(result, args.target_fidelity)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

qcoder/tools/qr_dll_bootstrap.py

@@ -0,0 +1,31 @@
+# qr_dll_bootstrap.py
+# Ensure CUDA DLLs are discoverable on Windows before importing QuantumRingsLib.
+
+import os
+import platform
+
+
+def setup_cuda_dll_search_paths() -> None:
+    if platform.system().lower() != "windows":
+        return
+
+    candidates = [
+        r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.1\bin",
+        r"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v13.1\bin\x64",
+    ]
+
+    for p in candidates:
+        if os.path.isdir(p):
+            os.add_dll_directory(p)
+
+
+def bootstrap() -> None:
+    """Canonical QCoder entrypoint for DLL/bootstrap setup."""
+    setup_cuda_dll_search_paths()
+
+
+# Back-compat aliases
+setup_dll_search_paths = setup_cuda_dll_search_paths
+
+# Run on import
+bootstrap()

qcoder/tools/runner.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""
+qcoder.tools.runner — entrypoint that delegates to Quantum Rings v12 runner.
+"""
+from qcoder.tools.runners.quantum_rings.v12.runner import main, die
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        die(f"Unhandled exception: {e}")

qcoder/tools/runners/__init__.py

@@ -0,0 +1 @@
+# Runner family implementations (e.g. quantum_rings/v12)

qcoder/tools/runners/quantum_rings/__init__.py

@@ -0,0 +1 @@
+# Quantum Rings SDK runner family

qcoder/tools/runners/quantum_rings/v12/__init__.py

@@ -0,0 +1 @@
+# Quantum Rings SDK v12 harness, runner, mirror