eqc-models 0.15.0__tar.gz → 0.15.1__tar.gz

{eqc_models-0.15.0 → eqc_models-0.15.1}/.gitignore

@@ -1,6 +1,6 @@
 __pycache__
 build
 eqc_models.egg-info
-
+scripts/test_reservoir.py
 *.c
 *.so

{eqc_models-0.15.0 → eqc_models-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.15.0
+Version: 0.15.1
 Summary: Optimization and ML modeling package targeting EQC devices
 Author-email: "Quantum Computing Inc." <support@quantumcomputinginc.com>
 Project-URL: Homepage, https://quantumcomputinginc.com

{eqc_models-0.15.0 → eqc_models-0.15.1}/docs/source/dependencies.rst

@@ -13,5 +13,5 @@ Packages
 - ``pandas >=2.1.0, <3``
 - ``scikit-learn >=1.2.1, <2``
 - ``lightgbm >= 4.6.0, <5``
-- ``xgboost >= 1.7.4, <2``
+- ``xgboost >= 1.7.4, <4``
 - ``qci-client>=5, <6``

{eqc_models-0.15.0 → eqc_models-0.15.1}/eqc_models/algorithms/alm.py

@@ -2,6 +2,7 @@
 from dataclasses import dataclass
 from typing import Callable, Dict, List, Tuple, Optional, Sequence, Union
 import numpy as np
+from collections import defaultdict
 from eqc_models.base.polynomial import PolynomialModel
 
 Array = np.ndarray
@@ -176,10 +177,90 @@ class ALMAlgorithm:
                     merged.append(((0, i + 1), float(ci)))
         return merged
 
+    @staticmethod
+    def _block_offsets(blocks: List[ALMBlock]) -> List[int]:
+        """
+        Return starting offsets (0-based) for each lifted block in the
+        concatenated s-vector.
+        """
+        offs, pos = [], 0
+        for blk in blocks:
+            offs.append(pos)
+            pos += len(blk.levels)     # each block contributes k lifted coordinates
+        return offs
+
+    @staticmethod
+    def lift_Qc_to_poly_terms(
+            Q_native: np.ndarray,       # shape (m, m) over original discrete vars (one block per var)
+            c_native: np.ndarray,       # shape (m,)
+            blocks: List[ALMBlock],     # ALM blocks (in the same order as the rows/cols of Q_native, c_native)
+    ) -> Tuple[List[Tuple[int, ...]], List[float]]:
+        """
+        Expand a quadratic/linear objective over m native discrete variables into the lifted
+        (one-hot) s-space.
+
+        Given `Q_native` and `c_native` over original m discrete vars (one block per var), and
+        `blocks` (`list[ALMBlock]` in the same order as original vars), we enforce:
+        - For variable i with level values b_i (length k_i), we create k_i lifted coords s_{i,a}.
+        - Quadratic term: J_ij = Q_native[i,j] * (b_i b_j^T) contributes to pairs (s_{i,a}, s_{j,b})
+        - Linear term: C_i = c_native[i] * b_i contributes to s_{i,a}
+
+        Returns polynomial (indices, coeffs) over concatenated s variables.
+        """
+        m = len(blocks)
+        assert Q_native.shape == (m, m), "Q_native must match number of blocks"
+        assert c_native.shape == (m,), "c_native must match number of blocks"
+
+        offs = ALMAlgorithm._block_offsets(blocks)
+        terms_acc = defaultdict(float)
+
+        # Quadratic lift: J = kron-expansion
+        for i in range(m):
+            bi = blocks[i].levels[:, None]                      # (k_i, 1)
+            oi = offs[i]
+            for j in range(m):
+                bj = blocks[j].levels[:, None]                  # (k_j, 1)
+                oj = offs[j]
+                J_ij = Q_native[i, j] * (bi @ bj.T)         # (k_i, k_j)
+                if np.allclose(J_ij, 0.0):
+                    continue
+                ki, kj = bi.shape[0], bj.shape[0]
+                for a in range(ki):
+                    ia = oi + a + 1
+                    for b in range(kj):
+                        jb = oj + b + 1
+                        w = float(J_ij[a, b])
+                        if w == 0.0:
+                            continue
+                        if ia == jb:
+                            terms_acc[(ia, ia)] += w
+                        else:
+                            # NOTE: we store each cross monomial once (i < j); for i==j block pairs,
+                            # double to represent J_ab + J_ba
+                            if i == j:                      # intra-block off-diagonal needs 2x
+                                w *= 2.0
+                            i1, i2 = (ia, jb) if ia < jb else (jb, ia)
+                            terms_acc[(i1, i2)] += w
+
+        # Linear lift: C_i = L_i * b_i
+        for i in range(m):
+            b = blocks[i].levels
+            oi = offs[i]
+            for a, val in enumerate(b):
+                ia = oi + a + 1
+                w = float(c_native[i] * val)
+                if w != 0.0:
+                    terms_acc[(0, ia)] += w
+
+        # Pack to PolynomialModel format
+        indices = [tuple(k) for k in terms_acc.keys()]
+        coeffs = [float(v) for v in terms_acc.values()]
+        return indices, coeffs
+
     # ---- main entrypoint ----
     @staticmethod
     def run(
-            model: PolynomialModel,
+            base_model: PolynomialModel,
             registry: ConstraintRegistry,
             solver,
             cfg: ALMConfig = ALMConfig(),
@@ -191,19 +272,92 @@ class ALMAlgorithm:
     ) -> Dict[str, Union[Array, Dict[int, float], Dict]]:
         """
         Solve with ALM. Keep all ALM state local to this call (no global side-effects).
+        Handles three modes:
+            (A) No blocks -> continuous; use base_model as-is
+            (B) Blocks + native base_model -> lift to s-space
+            (C) Blocks + already-lifted base_model -> use as-is (compat)
 
         Returns:
              {
                 "x": final iterate,
                 "decoded": {start_idx_of_block: level_value, ...} for lifted blocks,
+                "decoded_debug": {start_idx_of_block: native_device_value, ...},
                 "hist": { "eq_inf": [...], "ineq_inf": [...], "obj": [...], "x": [...] }
              }
         """
-        n = int(getattr(model, "n", len(getattr(model, "upper_bound", [])) or 0))
-        x = (np.asarray(x0, float).copy() if x0 is not None else
-             np.zeros(n, float))
+        blocks = registry.blocks
+        has_blocks = len(blocks) > 0
+
+        # ---- choose working model + dimension n ----
+        if not has_blocks:
+            # (A) continuous case: use the provided model directly
+            model = base_model
+            # Prefer model.n, fall back to bounds; else infer from polynomial indices
+            n = getattr(model, "n", None)
+            if n is None:
+                ub = getattr(model, "upper_bound", None)
+                lb = getattr(model, "lower_bound", None)
+                if ub is not None:
+                    n = len(ub)
+                elif lb is not None:
+                    n = len(lb)
+                else:
+                    # infer from polynomial terms
+                    n = 0
+                    for inds in getattr(model, "indices", getattr(model.polynomial, "indices", [])):
+                        for j in inds:
+                            if max(j) > 0:
+                                n = max(n, j)
+            lifted_slices: List[List[int]] = []
+
+        else:
+            # (B/C) lifted (discrete) case
+            target_lifted_n = sum(len(blk.levels) for blk in blocks)
+            base_n = getattr(base_model, "n", None)
+
+            # detect "already-lifted" native input (compat path)
+            already_lifted = (base_n == target_lifted_n)
+
+            if already_lifted:
+                # (C) use provided model directly; assume bounds already sensible
+                model = base_model
+                n = target_lifted_n
+            else:
+                # (B) lift from native space
+                # base_model must expose coefficients/indices compatible with this call
+                c_base, Q_base = base_model._quadratic_polynomial_to_qubo_coefficients(
+                    getattr(base_model, "coefficients", getattr(base_model.polynomial, "coefficients", [])),
+                    getattr(base_model, "indices", getattr(base_model.polynomial, "indices", [])),
+                    getattr(base_model, "n")
+                )
+                assert Q_base.shape[0] == Q_base.shape[1]
+                assert c_base.shape[0] == Q_base.shape[0]
+                indices_lifted, coeffs_lifted = ALMAlgorithm.lift_Qc_to_poly_terms(Q_base, c_base, blocks)
+                model = PolynomialModel(coeffs_lifted, indices_lifted)
+                n = target_lifted_n
+                # set canonical [0,1] bounds for lifted s
+                setattr(model, "lower_bound", np.zeros(n, float))
+                setattr(model, "upper_bound", np.ones(n, float))
+
+            # ---- n and lifted_slices ----
+            lifted_slices = []
+            pos = 0
+            for blk in blocks:
+                k = len(blk.levels)                                 # number of lifted coords for this block
+                lifted_slices.append(list(range(pos, pos + k)))     # 0-based in lifted x
+                pos += k
+
+        # Algorithm initial solution and bounds
         lb = getattr(model, "lower_bound", None)
         ub = getattr(model, "upper_bound", None)
+        if x0 is not None:
+            x = np.asarray(x0, float).copy()
+        else:
+            # default init
+            if (lb is not None) and (ub is not None) and np.all(np.isfinite(lb)) and np.all(np.isfinite(ub)):
+                x = 0.5 * (np.asarray(lb, float) + np.asarray(ub, float))
+            else:
+                x = np.zeros(n, float)
 
         # ---- collect constraints ----
         problem_eqs = [c for c in registry.constraints if c.kind == "eq"]
@@ -212,24 +366,26 @@ class ALMAlgorithm:
         # auto-install sum-to-one and one-hot as equalities
         # (One-hot: s^T (11^T - I) s = 0))
         def _install_block_equalities() -> List[ALMConstraint]:
+            if not has_blocks:
+                return []
             eqs: List[ALMConstraint] = []
-            for blk in registry.blocks:
+            for blk, lift_idx in zip(registry.blocks, lifted_slices):
                 if blk.enforce_sum_to_one:
-                    S = ALMAlgorithm._sum_to_one_selector(n, blk.idx)
+                    S = ALMAlgorithm._sum_to_one_selector(n, lift_idx)
                     eqs.append(ALMConstraint(
                         "eq",
                         fun=ALMAlgorithm._make_sum1_fun(S),
                         jac=ALMAlgorithm._make_sum1_jac(S),
-                        name=f"sum_to_one_block_{blk.idx[0]}",
+                        name=f"sum_to_one_block_{lift_idx[0]}",
                     ))
                 if blk.enforce_one_hot:
-                    k = len(blk.idx)
+                    k = len(lift_idx)
                     M = ALMAlgorithm._pairwise_M(k)
                     eqs.append(ALMConstraint(
                         "eq",
-                        fun=ALMAlgorithm._make_onehot_fun(blk.idx, M),
-                        jac=ALMAlgorithm._make_onehot_jac(blk.idx, M, n),
-                        name=f"onehot_block_{blk.idx[0]}",
+                        fun=ALMAlgorithm._make_onehot_fun(lift_idx, M),
+                        jac=ALMAlgorithm._make_onehot_jac(lift_idx, M, n),
+                        name=f"onehot_block_{lift_idx[0]}",
                     ))
             return eqs
 
@@ -274,7 +430,6 @@ class ALMAlgorithm:
 
         for it in range(cfg.max_outer):
             # -------- base polynomial (does not include fixed penalties here) --------
-            # base_terms: List[PolyTerm] = list(getattr(model, "polynomial"))
             base_terms: List[PolyTerm] = list(zip(model.polynomial.indices, model.polynomial.coefficients))
 
             # -------- ALM quadratic/linear pieces (assembled here, kept separate) --------
@@ -451,14 +606,25 @@ class ALMAlgorithm:
             prev_eq_inf = max(eq_inf_smooth, eps)
             prev_ineq_inf = max(ineq_inf_smooth, eps)
 
-        # optional decoding for lifted blocks
-        decoded: Dict[int, Union[int, float]] = {}
-        for blk in registry.blocks:
-            sl = np.array(blk.idx, int)
-            if len(sl) == 0:
-                continue
-            s = x[sl]
-            j = int(np.argmax(s))
-            decoded[sl[0]] = float(blk.levels[j])
-
-        return {"x": x, "decoded": decoded, "hist": hist}
+        # ---- decoding back to native levels (only if blocks) ----
+        decoded_native: Dict[int, float] = {}           # maps original var anchor -> chosen level value
+        decoded_lifted: Dict[int, int] = {}             # maps lifted start index -> argmax position (optional)
+        if has_blocks:
+            for blk, lift_idx in zip(registry.blocks, lifted_slices):
+                if not lift_idx:
+                    continue
+                sl = np.array(lift_idx, int)
+                if len(sl) == 0:
+                    continue
+                sblk = x[sl]
+                j = int(np.argmax(sblk))                    # which level got selected in the block
+                orig_anchor = int(blk.idx[0])               # anchor original var id for this block
+                decoded_native[orig_anchor] = float(blk.levels[j])
+                decoded_lifted[sl[0]] = j                   # optional: lifted index -> chosen slot
+
+        return {
+            "x": x,
+            "decoded": decoded_native if has_blocks else {},
+            "decoded_debug": decoded_lifted if has_blocks else {},
+            "hist": hist,
+        }

eqc_models-0.15.1/eqc_models/ml/utils.py

@@ -0,0 +1,132 @@
+import numpy as np
+from sklearn.metrics import (
+    auc,
+    precision_recall_curve,
+    roc_auc_score,
+    precision_score,
+    recall_score,
+    accuracy_score,
+    f1_score,
+    confusion_matrix,
+)
+
+
+def get_binary_classification_metrics(
+    y_true, y_pred, positive_label=1, negative_label=-1, threshold=0
+):
+    """Compute classifier merits.
+
+    Parameters
+    ----------
+    y_true: Actual labels (array-like of shape (n_samples,)).
+
+    y_pred: Predicted scores between negative and positive labels
+    (array-like of shape (n_samples,)).
+
+    positive_label: The positive label (integer; default: 1).
+
+    negative_label: The negative label (integer; default: -1).
+
+    threshold: Threshold for converting y_pred scores to predicted
+    labels, float; default: 0.
+
+    Returns
+    -------
+    Dict.
+
+    """
+
+    # Convert to numpy arrays
+    y_true = np.asarray(y_true).ravel()
+    y_pred = np.asarray(y_pred).ravel()
+
+    # Some sanity checks
+    if y_true.ndim != 1 or y_pred.ndim != 1:
+        raise ValueError(
+            "y_true and y_pred must be 1D arrays (or array-like)."
+        )
+    if y_true.shape[0] != y_pred.shape[0]:
+        raise ValueError(
+            f"Size mismatch: y_true has {y_true.shape[0]} elements, "
+            f"y_pred has {y_pred.shape[0]} elements."
+        )
+    if y_true.shape[0] == 0:
+        raise ValueError(
+            "Empty inputs: y_true/y_pred must have at least 1 element."
+        )
+
+    try:
+        positive_label = int(positive_label)
+    except Exception as e:
+        raise TypeError("positive_label must be an integer.") from e
+
+    try:
+        negative_label = int(negative_label)
+    except Exception as e:
+        raise TypeError("negative_label must be an integer.") from e
+
+    try:
+        threshold = float(threshold)
+    except Exception as e:
+        raise TypeError("threshold must be a float.") from e
+
+    assert (
+        positive_label != negative_label
+    ), "Positive and negative labels should not be equal!"
+
+    y_true = y_true.astype(int)
+    assert set(y_true) == {
+        positive_label,
+        negative_label,
+    }, "Incorrect labels!"
+
+    # Convert predicted scores to labels
+    dist_pos = np.abs(y_pred - positive_label)
+    dist_neg = np.abs(y_pred - negative_label)
+    y_pred_label = np.where(
+        dist_pos <= dist_neg, positive_label, negative_label
+    )
+
+    assert set(y_pred_label) == {
+        positive_label,
+        negative_label,
+    }, "Incorrect labels!"
+
+    # Calculate the metrics
+    precision, recall, _ = precision_recall_curve(y_true, y_pred)
+    pr_auc = auc(recall, precision)
+
+    out_hash = {
+        "positive_label": positive_label,
+        "negative_label": negative_label,
+        "threshold": threshold,
+        "pr_auc": pr_auc,
+        "roc_auc": roc_auc_score(y_true, y_pred),
+        "precision": precision_score(
+            y_true,
+            y_pred_label,
+            zero_division=0,
+            labels=[negative_label, positive_label],
+            pos_label=positive_label,
+        ),
+        "recall": recall_score(
+            y_true,
+            y_pred_label,
+            zero_division=0,
+            labels=[negative_label, positive_label],
+            pos_label=positive_label,
+        ),
+        "accuracy": accuracy_score(y_true, y_pred_label),
+        "f1_score": f1_score(
+            y_true,
+            y_pred_label,
+            zero_division=0,
+            labels=[negative_label, positive_label],
+            pos_label=positive_label,
+        ),
+        "confusion_matrix": confusion_matrix(
+            y_true, y_pred_label, labels=[negative_label, positive_label]
+        ),
+    }
+
+    return out_hash

{eqc_models-0.15.0 → eqc_models-0.15.1}/eqc_models.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.15.0
+Version: 0.15.1
 Summary: Optimization and ML modeling package targeting EQC devices
 Author-email: "Quantum Computing Inc." <support@quantumcomputinginc.com>
 Project-URL: Homepage, https://quantumcomputinginc.com

{eqc_models-0.15.0 → eqc_models-0.15.1}/eqc_models.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ eqc_models/ml/forecastbase.py
 eqc_models/ml/regressor.py
 eqc_models/ml/regressorbase.py
 eqc_models/ml/reservoir.py
+eqc_models/ml/utils.py
 eqc_models/process/base.py
 eqc_models/process/mpc.py
 eqc_models/sequence/__init__.py
@@ -121,6 +122,7 @@ scripts/qsvm_iris_dirac3.py
 scripts/reservoir_forecast.py
 scripts/results_example.py
 scripts/rundoctests.py
+scripts/test_reservoir.py
 scripts/test_shortestpath.py
 scripts/utils.py
 test/doctest_base.py

{eqc_models-0.15.0 → eqc_models-0.15.1}/scripts/qboost_iris_dirac3.py

@@ -15,6 +15,8 @@ from sklearn.metrics import (
 )
 
 from eqc_models.ml.classifierqboost import QBoostClassifier
+from eqc_models.ml.utils import get_binary_classification_metrics
+
 
 # Set parameters
 TEST_SIZE = 0.2
@@ -61,51 +63,39 @@ obj = QBoostClassifier(
     api_url=API_URL,
     api_token=API_TOKEN,
     ip_addr=IP_ADDR,
-    port=PORT,    
+    port=PORT,
     lambda_coef=0.0,
     weak_cls_schedule=1,
-    weak_cls_pair_count=None,    
+    weak_cls_pair_count=None,
 )
 
 # Train
 obj.fit(X_train, y_train)
 
-y_train_prd = obj.predict(X_train)
-y_test_prd = obj.predict(X_test)
+y_train_prd = obj.predict_raw(X_train)
+y_test_prd = obj.predict_raw(X_test)
 
 print(Counter(y_train_prd))
 print(Counter(y_test_prd))
 
 print(
-    "Train precision:",
-    precision_score(y_train, y_train_prd, labels=[-1, 1], pos_label=1),
-)
-print(
-    "Train recall:",
-    recall_score(y_train, y_train_prd, labels=[-1, 1], pos_label=1),
-)
-print(
-    "Train accuracy:",
-    accuracy_score(y_train, y_train_prd),
-)
-print(
-    "Train confusion matrix:",
-    confusion_matrix(y_train, y_train_prd, labels=[-1, 1]),
+    "Train data metrics:",
+    get_binary_classification_metrics(
+        y_train,
+        y_train_prd,
+        positive_label=1,
+        negative_label=-1,
+        threshold=0,
+    ),
 )
 
 print(
-    "Test precision:",
-    precision_score(y_test, y_test_prd, labels=[-1, 1], pos_label=1),
-)
-print(
-    "Test recall:",
-    recall_score(y_test, y_test_prd, labels=[-1, 1], pos_label=1),
-)
-print(
-    "Test accuracy:",
-    accuracy_score(y_test, y_test_prd),
-)
-print(
-    "Test confusion matrix:",
-    confusion_matrix(y_test, y_test_prd, labels=[-1, 1]),
+    "Test data metrics:",
+    get_binary_classification_metrics(
+        y_test,
+        y_test_prd,
+        positive_label=1,
+        negative_label=-1,
+        threshold=0,
+    ),
 )

eqc_models-0.15.1/scripts/test_reservoir.py

@@ -0,0 +1,48 @@
+import os
+import pandas as pd
+from eqc_models.ml import ReservoirForecastModel
+
+# Deine parameters
+INP_FILE = "mackey_glass_cell_production_series.csv"
+
+MAX_TRAIN_DAY = 800
+IP_ADDR = os.environ["EMUCORE_IP_ADDR"]
+FEATURE_SCALING = 0.1
+NUM_NODES = 1000
+NUM_PADS = 100
+LAGS = 2
+
+# Prepare input time series
+df = pd.read_csv(INP_FILE)
+
+train_df = df[df["days"] <= MAX_TRAIN_DAY]
+test_df = df[df["days"] > MAX_TRAIN_DAY]
+
+# Train a forecast model
+model = ReservoirForecastModel(
+    ip_addr=IP_ADDR,
+    num_nodes=NUM_NODES,
+    feature_scaling=FEATURE_SCALING,
+    num_pads=NUM_PADS,
+    device="EmuCore",
+)
+
+model.fit(
+    data=train_df,
+    feature_fields=["norm_cell_prod"],
+    target_fields=["norm_cell_prod"],
+    lags=LAGS,
+    horizon_size=1,
+)
+
+y_train_pred = model.predict(train_df, mode="in_sample")
+
+print(y_train_pred)
+print(y_train_pred.shape)
+
+y_test_pred = model.predict(test_df, mode="in_sample")
+
+print(y_test_pred)
+print(y_test_pred.shape)
+
+model.close()