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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.15.1
+Version: 0.15.3
 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.1 → eqc_models-0.15.3}/eqc_models/algorithms/alm.py

@@ -1,5 +1,5 @@
 # (C) Quantum Computing Inc., 2025.
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Callable, Dict, List, Tuple, Optional, Sequence, Union
 import numpy as np
 from collections import defaultdict
@@ -16,6 +16,7 @@ class ALMConstraint:
     fun: Callable[[Array], Array]                       # h(x) or g(x)
     jac: Optional[Callable[[Array], Array]] = None
     name: str = ""
+    family: str = ""
 
 
 @dataclass
@@ -34,6 +35,11 @@ class ALMConfig:
     rho_g: float = 50.0                                 # inequalities / one-hot
     rho_min: float = 1e-3
     rho_max: float = 1e3
+    # per-family penalty overrides
+    rho_eq_family: Dict[str, float] = field(default_factory=dict)
+    rho_ineq_family: Dict[str, float] = field(default_factory=dict)
+    # allow per-family adaptation toggle  (optional)
+    adapt_by_family: bool = True
     # adaptation toggles
     adapt: bool = True
     tau_up_h: float = 0.90
@@ -68,11 +74,11 @@ class ConstraintRegistry:
         self.constraints: List[ALMConstraint] = []
         self.blocks: List[ALMBlock] = []
 
-    def add_equality(self, fun, jac=None, name=""):
-        self.constraints.append(ALMConstraint("eq", fun, jac, name))
+    def add_equality(self, fun, jac=None, name="", family=""):
+        self.constraints.append(ALMConstraint("eq", fun, jac, name, family))
 
-    def add_inequality(self, fun, jac=None, name=""):
-        self.constraints.append(ALMConstraint("ineq", fun, jac, name))
+    def add_inequality(self, fun, jac=None, name="", family=""):
+        self.constraints.append(ALMConstraint("ineq", fun, jac, name, family))
 
     def add_block(self, idx: Sequence[int], levels: Array, sum_to_one=True, one_hot=True):
         self.blocks.append(ALMBlock(list(idx), np.asarray(levels, float), sum_to_one, one_hot))
@@ -306,7 +312,7 @@ class ALMAlgorithm:
                     n = 0
                     for inds in getattr(model, "indices", getattr(model.polynomial, "indices", [])):
                         for j in inds:
-                            if max(j) > 0:
+                            if j > 0:
                                 n = max(n, j)
             lifted_slices: List[List[int]] = []
 
@@ -315,6 +321,18 @@ class ALMAlgorithm:
             target_lifted_n = sum(len(blk.levels) for blk in blocks)
             base_n = getattr(base_model, "n", None)
 
+            def _infer_n_from_terms(pm: PolynomialModel) -> int:
+                inds_list = getattr(pm, "indices", getattr(pm.polynomial, "indices", []))
+                mx = 0
+                for inds in inds_list:
+                    for j in inds:
+                        if j > mx:
+                            mx = j
+                return int(mx)
+
+            if base_n is None:
+                base_n = _infer_n_from_terms(base_model)
+
             # detect "already-lifted" native input (compat path)
             already_lifted = (base_n == target_lifted_n)
 
@@ -377,6 +395,7 @@ class ALMAlgorithm:
                         fun=ALMAlgorithm._make_sum1_fun(S),
                         jac=ALMAlgorithm._make_sum1_jac(S),
                         name=f"sum_to_one_block_{lift_idx[0]}",
+                        family="block_sum1",
                     ))
                 if blk.enforce_one_hot:
                     k = len(lift_idx)
@@ -386,6 +405,7 @@ class ALMAlgorithm:
                         fun=ALMAlgorithm._make_onehot_fun(lift_idx, M),
                         jac=ALMAlgorithm._make_onehot_jac(lift_idx, M, n),
                         name=f"onehot_block_{lift_idx[0]}",
+                        family="block_onehot",
                     ))
             return eqs
 
@@ -406,16 +426,34 @@ class ALMAlgorithm:
             r0 = csp.fun(x).reshape(-1)
             mu_ineq.append(np.zeros_like(r0, dtype=float))
 
+        rho_eq_family = dict(getattr(cfg, "rho_eq_family", {}) or {})
+        rho_ineq_family = dict(getattr(cfg, "rho_ineq_family", {}) or {})
+
+        def _rho_for(csp_k: ALMConstraint) -> float:
+            fam = getattr(csp_k, "family", "") or ""
+            if csp_k.kind == "eq":
+                return float(rho_eq_family.get(fam, rho_h))
+            else:
+                return float(rho_ineq_family.get(fam, rho_g))
+
         # -------- running stats for adaptive penalties --------
         rho_h, rho_g = cfg.rho_h, cfg.rho_g
         best_eq, best_ineq = np.inf, np.inf
         no_imp_eq = no_imp_ineq = 0
         prev_eq_inf, prev_ineq_inf = np.inf, np.inf
         eps = 1e-12
+        prev_eq_inf_by_family, prev_ineq_inf_by_family = {}, {}
+        # ---- per-family stagnation tracking (only used when cfg.adapt_by_family=True)
+        best_eq_by_family: Dict[str, float] = {}
+        best_ineq_by_family: Dict[str, float] = {}
+        no_imp_eq_by_family: Dict[str, int] = {}
+        no_imp_ineq_by_family: Dict[str, int] = {}
 
         hist = {"eq_inf": [], "ineq_inf": [], "obj": [], "x": [],
                 # per-iteration logs for parameters/multipliers
                 "rho_h": [], "rho_g": [],
+                "rho_eq_family": [], "rho_ineq_family": [],
+                "eq_inf_by_family": [], "ineq_inf_by_family": [],
                 }
         for k_idx, csp in enumerate(full_eqs):
             if csp.kind != "eq":
@@ -447,8 +485,9 @@ class ALMAlgorithm:
                 assert A.shape[1] == n, f"A has {A.shape[1]} cols, expected {n}"
                 # linearization about current x: residual model r(x) = A x - b, with b = A x - h
                 b = A @ x - h
-                Qk = 0.5 * rho_h * (A.T @ A)
-                ck = (A.T @ lam_eq[k_idx]) - rho_h * (A.T @ b)
+                rho_k = _rho_for(csp)
+                Qk = 0.5 * rho_k * (A.T @ A)
+                ck = (A.T @ lam_eq[k_idx]) - rho_k * (A.T @ b)
                 Q_aug += Qk
                 c_aug += ck
                 have_aug = True
@@ -462,18 +501,19 @@ class ALMAlgorithm:
                 G = np.atleast_2d(G)
                 assert G.shape[1] == n, f"G has {G.shape[1]} cols, expected {n}"
                 d = G @ x - g
+                rho_k = _rho_for(csp)
                 # Activation measure at current iterate; meaning, the current violating inequality components:
                 # g(x) + mu/rho; Powell-Hestenes-Rockafellar shifted residual
-                y = G @ x - d + mu_ineq[k_idx] / rho_g
+                y = G @ x - d + mu_ineq[k_idx] / rho_k
                 active = (y > cfg.act_tol)
                 if np.any(active):
                     GA = G[active, :]
                     muA = mu_ineq[k_idx][active]
                     gA = g[active]
                     # Q += (rho/2) * GA^T GA
-                    Qk = 0.5 * rho_g * (GA.T @ GA)
+                    Qk = 0.5 * rho_k * (GA.T @ GA)
                     # c += GA^T mu - rho * GA^T (GA x - gA); where GA x - gA is active measures of d = G @ x - g
-                    ck = (GA.T @ muA) - rho_g * (GA.T @ (GA @ x - gA))
+                    ck = (GA.T @ muA) - rho_k * (GA.T @ (GA @ x - gA))
                     Q_aug += Qk
                     c_aug += ck
                     have_aug = True
@@ -514,12 +554,23 @@ class ALMAlgorithm:
                     x = getattr(out, "x", out)
                 x = np.asarray(x, float)
 
+            # ---- multiplier tracking ----
+            for k_idx, csp in enumerate(full_eqs):
+                if csp.kind != "eq": continue
+                hist[f"lam_eq_max_idx{k_idx}"].append(float(np.max(lam_eq[k_idx])))
+                hist[f"lam_eq_min_idx{k_idx}"].append(float(np.min(lam_eq[k_idx])))
+            for k_idx, csp in enumerate(problem_ineqs):
+                if csp.kind != "ineq": continue
+                hist[f"mu_ineq_max_idx{k_idx}"].append(float(np.max(mu_ineq[k_idx])))
+                hist[f"mu_ineq_min_idx{k_idx}"].append(float(np.min(mu_ineq[k_idx])))
+
             # -------- residuals + multiplier updates --------
             eq_infs = []
             for k_idx, csp in enumerate(full_eqs):
                 if csp.kind != "eq": continue
                 r = csp.fun(x).reshape(-1)
-                lam_eq[k_idx] = lam_eq[k_idx] + rho_h * r
+                rho_k = _rho_for(csp)
+                lam_eq[k_idx] = lam_eq[k_idx] + rho_k * r
                 if r.size:
                     eq_infs.append(np.max(np.abs(r)))
             eq_inf = float(np.max(eq_infs)) if eq_infs else 0.0
@@ -528,7 +579,8 @@ class ALMAlgorithm:
             for k_idx, csp in enumerate(problem_ineqs):
                 if csp.kind != "ineq": continue
                 r = csp.fun(x).reshape(-1)
-                mu_ineq[k_idx] = np.maximum(0.0, mu_ineq[k_idx] + rho_g * r)
+                rho_k = _rho_for(csp)
+                mu_ineq[k_idx] = np.maximum(0.0, mu_ineq[k_idx] + rho_k * r)
                 if r.size:
                     ineq_infs.append(np.max(np.maximum(0.0, r)))
             ineq_inf = float(np.max(ineq_infs)) if ineq_infs else 0.0
@@ -536,25 +588,55 @@ class ALMAlgorithm:
             assert len(lam_eq) == len(full_eqs)
             assert len(mu_ineq) == len(problem_ineqs)
 
+            # ---- per-family residual telemetry ----
+            eq_inf_by_family = {}
+            for k_idx, csp in enumerate(full_eqs):
+                if csp.kind != "eq": continue
+                fam = getattr(csp, "family", "") or ""
+                r = csp.fun(x).reshape(-1)
+                v = float(np.max(np.abs(r))) if r.size else 0.0
+                eq_inf_by_family[fam] = max(eq_inf_by_family.get(fam, 0.0), v)
+
+            ineq_inf_by_family = {}
+            for k_idx, csp in enumerate(problem_ineqs):
+                if csp.kind != "ineq": continue
+                fam = getattr(csp, "family", "") or ""
+                r = csp.fun(x).reshape(-1)
+                v = float(np.max(np.maximum(0.0, r))) if r.size else 0.0
+                ineq_inf_by_family[fam] = max(ineq_inf_by_family.get(fam, 0.0), v)
+
             # evaluate base polynomial only (ca add aug value if want to track full L_A)
             f_val = ALMAlgorithm._poly_value(base_terms, x)
 
             hist["eq_inf"].append(eq_inf); hist["ineq_inf"].append(ineq_inf)
             hist["obj"].append(float(f_val)); hist["x"].append(x.copy())
-            # parameter & multiplier tracking
+            # parameter tracking
             hist["rho_h"].append(float(rho_h)); hist["rho_g"].append(float(rho_g))
-            for k_idx, csp in enumerate(full_eqs):
-                if csp.kind != "eq": continue
-                hist[f"lam_eq_max_idx{k_idx}"].append(float(np.max(lam_eq[k_idx])))
-                hist[f"lam_eq_min_idx{k_idx}"].append(float(np.min(lam_eq[k_idx])))
-            for k_idx, csp in enumerate(problem_ineqs):
-                if csp.kind != "ineq": continue
-                hist[f"mu_ineq_max_idx{k_idx}"].append(float(np.max(mu_ineq[k_idx])))
-                hist[f"mu_ineq_min_idx{k_idx}"].append(float(np.min(mu_ineq[k_idx])))
+            hist["rho_eq_family"].append(dict(rho_eq_family))
+            hist["rho_ineq_family"].append(dict(rho_ineq_family))
+            hist["eq_inf_by_family"].append(dict(eq_inf_by_family))
+            hist["ineq_inf_by_family"].append(dict(ineq_inf_by_family))
 
             if verbose:
+                # show worst 3 equality families by residual, with their rhos
+                eq_items = sorted(eq_inf_by_family.items(), key=lambda kv: kv[1], reverse=True)
+                eq_top = eq_items[:3]
+                eq_str = ",".join([
+                    f"{fam or 'eq'}:{val:.2e}@"
+                    f"{_rho_for(next(c for c in full_eqs if (getattr(c,'family','') or '')==fam and c.kind=='eq')):.1g}"
+                    for fam, val in eq_top
+                ])
+                # show worst 3 inequality families by residual, with their rhos
+                ineq_items = sorted(ineq_inf_by_family.items(), key=lambda kv: kv[1], reverse=True)
+                ineq_top = ineq_items[:3]
+                ineq_str = ",".join([
+                    f"{fam or 'ineq'}:{val:.2e}@"
+                    f"{_rho_for(next(c for c in problem_ineqs if (getattr(c, 'family', '') or '') == fam and c.kind == 'ineq')):.1g}"
+                    for fam, val in ineq_top
+                ])
+
                 print(f"[ALM {it:02d}] f={f_val:.6g} | eq_inf={eq_inf:.2e} | ineq_inf={ineq_inf:.2e} "
-                      f"| rho_h={rho_h:.2e} | rho_g={rho_g:.2e}")
+                      f"| rho_h={rho_h:.2e} | rho_g={rho_g:.2e} | eq_fam[{eq_str}] | ineq_fam[{ineq_str}]")
 
             # stopping
             if eq_inf <= cfg.tol_h and ineq_inf <= cfg.tol_g:
@@ -572,35 +654,105 @@ class ALMAlgorithm:
 
             # -------- Residual-ratio controller --------
             if cfg.adapt and it > 0:
-                # Equality group
-                if eq_inf_smooth > cfg.tau_up_h * max(prev_eq_inf, eps):          # stalled or not shrinking
-                    rho_h = min(cfg.gamma_up * rho_h, cfg.rho_max)
-                elif eq_inf_smooth < cfg.tau_down_h * max(prev_eq_inf, eps):      # fast progress, allow relaxation
-                    rho_h = max(cfg.gamma_down * rho_h, cfg.rho_min)
-
-                # Inequality group
-                if ineq_inf_smooth > cfg.tau_up_g * max(prev_ineq_inf, eps):
-                    rho_g = min(cfg.gamma_up * rho_g, cfg.rho_max)
-                elif ineq_inf_smooth < cfg.tau_down_g * max(prev_ineq_inf, eps):
-                    rho_g = max(cfg.gamma_down * rho_g, cfg.rho_min)
+                # per-family rho adaptation for equalities
+                if getattr(cfg, "adapt_by_family", False):
+                    # Equality family
+                    for fam, cur in eq_inf_by_family.items():
+                        prev = max(prev_eq_inf_by_family.get(fam, cur), eps)
+                        # rho value for family: if absent, start at rho_h
+                        rho_f = float(rho_eq_family.get(fam, rho_h))
+                        if cur > cfg.tau_up_h * prev:
+                            rho_f = min(cfg.gamma_up * rho_f, cfg.rho_max)
+                        elif cur < cfg.tau_down_h * prev:
+                            rho_f = max(cfg.gamma_down * rho_f, cfg.rho_min)
+                        rho_eq_family[fam] = rho_f
+                    # update prev map
+                    prev_eq_inf_by_family = dict(eq_inf_by_family)
+
+                    # Inequality family
+                    for fam, cur in ineq_inf_by_family.items():
+                        prev = max(prev_ineq_inf_by_family.get(fam, cur), eps)
+                        # rho value for family: if absent, start at rho_g
+                        rho_f = float(rho_ineq_family.get(fam, rho_g))
+                        if cur > cfg.tau_up_g * prev:
+                            rho_f = min(cfg.gamma_up * rho_f, cfg.rho_max)
+                        elif cur < cfg.tau_down_g * prev:
+                            rho_f = max(cfg.gamma_down * rho_f, cfg.rho_min)
+                        rho_ineq_family[fam] = rho_f
+                    # update prev map
+                    prev_ineq_inf_by_family = dict(ineq_inf_by_family)
+                else:
+                    # Equality group
+                    if eq_inf_smooth > cfg.tau_up_h * max(prev_eq_inf, eps):          # stalled or not shrinking
+                        rho_h = min(cfg.gamma_up * rho_h, cfg.rho_max)
+                    elif eq_inf_smooth < cfg.tau_down_h * max(prev_eq_inf, eps):      # fast progress, allow relaxation
+                        rho_h = max(cfg.gamma_down * rho_h, cfg.rho_min)
+
+                    # Inequality group
+                    if ineq_inf_smooth > cfg.tau_up_g * max(prev_ineq_inf, eps):
+                        rho_g = min(cfg.gamma_up * rho_g, cfg.rho_max)
+                    elif ineq_inf_smooth < cfg.tau_down_g * max(prev_ineq_inf, eps):
+                        rho_g = max(cfg.gamma_down * rho_g, cfg.rho_min)
+            else:
+                # per-family rho adaptation for equalities
+                if getattr(cfg, "adapt_by_family", False):
+                    # update prev map
+                    prev_eq_inf_by_family = dict(eq_inf_by_family)
+                    prev_ineq_inf_by_family = dict(ineq_inf_by_family)
 
             # -------- Stagnation bump (safety net) --------
             if cfg.use_stagnation_bump:
-                # Equality stagnation
-                if eq_inf <= best_eq * (1 - cfg.stagnation_factor):
-                    best_eq = eq_inf; no_imp_eq = 0
-                else:
-                    no_imp_eq += 1
-                    if no_imp_eq >= cfg.patience_h:
-                        rho_h = min(2.0 * rho_h, cfg.rho_max); no_imp_eq = 0
+                if getattr(cfg, "adapt_by_family", False):
+                    # ---- Equality families ----
+                    for fam, cur in eq_inf_by_family.items():
+                        # initialize
+                        if fam not in best_eq_by_family:
+                            best_eq_by_family[fam] = float(cur)
+                            no_imp_eq_by_family[fam] = 0
+
+                        if cur <= best_eq_by_family[fam] * (1 - cfg.stagnation_factor):
+                            best_eq_by_family[fam] = float(cur)
+                            no_imp_eq_by_family[fam] = 0
+                        else:
+                            no_imp_eq_by_family[fam] += 1
+                            if no_imp_eq_by_family[fam] >= cfg.patience_h:
+                                rho_f = float(rho_eq_family.get(fam, rho_h))
+                                rho_eq_family[fam] = min(2.0 * rho_f, cfg.rho_max)
+                                no_imp_eq_by_family[fam] = 0
+
+                    # ---- Inequality families ----
+                    for fam, cur in ineq_inf_by_family.items():
+                        # initialize
+                        if fam not in best_ineq_by_family:
+                            best_ineq_by_family[fam] = float(cur)
+                            no_imp_ineq_by_family[fam] = 0
+
+                        if cur <= best_ineq_by_family[fam] * (1 - cfg.stagnation_factor):
+                            best_ineq_by_family[fam] = float(cur)
+                            no_imp_ineq_by_family[fam] = 0
+                        else:
+                            no_imp_ineq_by_family[fam] += 1
+                            if no_imp_ineq_by_family[fam] >= cfg.patience_g:
+                                rho_f = float(rho_ineq_family.get(fam, rho_g))
+                                rho_ineq_family[fam] = min(2.0 * rho_f, cfg.rho_max)
+                                no_imp_ineq_by_family[fam] = 0
 
-                # Inequality stagnation
-                if ineq_inf <= best_ineq * (1 - cfg.stagnation_factor):
-                    best_ineq = ineq_inf; no_imp_ineq = 0
                 else:
-                    no_imp_ineq += 1
-                    if no_imp_ineq >= cfg.patience_g:
-                        rho_g = min(2.0 * rho_g, cfg.rho_max); no_imp_ineq = 0
+                    # Equality stagnation
+                    if eq_inf <= best_eq * (1 - cfg.stagnation_factor):
+                        best_eq = eq_inf; no_imp_eq = 0
+                    else:
+                        no_imp_eq += 1
+                        if no_imp_eq >= cfg.patience_h:
+                            rho_h = min(2.0 * rho_h, cfg.rho_max); no_imp_eq = 0
+
+                    # Inequality stagnation
+                    if ineq_inf <= best_ineq * (1 - cfg.stagnation_factor):
+                        best_ineq = ineq_inf; no_imp_ineq = 0
+                    else:
+                        no_imp_ineq += 1
+                        if no_imp_ineq >= cfg.patience_g:
+                            rho_g = min(2.0 * rho_g, cfg.rho_max); no_imp_ineq = 0
 
             # -------- finalize for next iteration --------
             prev_eq_inf = max(eq_inf_smooth, eps)

{eqc_models-0.15.1 → eqc_models-0.15.3}/eqc_models/graph/rcshortestpath.py

@@ -68,8 +68,9 @@ class RCShortestPathModel(ShortestPathModel):
         path_len = 0
         path_cost = 0
         path_resources = 0
-        while node != t:
+        while node != self.t:
             edge = (node, path[node])
+            log.debug("Processing edge %s for pathCost", edge)
             if edge not in G.edges:
                 raise ValueError(f"Edge {edge} not found")
             path_len += 1
@@ -77,5 +78,6 @@ class RCShortestPathModel(ShortestPathModel):
             path_resources += G.edges[edge][self.resource_key]
             if path_len > max_len:
                 raise ValueError("Invalid path. Describes a cycle.")
+            node = edge[1]
         return path_cost, path_resources
 

{eqc_models-0.15.1 → eqc_models-0.15.3}/eqc_models/graph/shortestpath.py

@@ -200,13 +200,15 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
         max_len = len(self.G.nodes) - 1
         path_len = 0
         path_cost = 0
-        while node != t:
+        while node != self.t:
             edge = (node, path[node])
+            log.debug("Processing edge %s for pathCost", edge)
             if edge not in G.edges:
                 raise ValueError(f"Edge {edge} not found")
             path_len += 1
             path_cost += G.edges[edge]["weight"]
             if path_len > max_len:
-                raise ValueError("Invalid path. Describes a cycle.")
+                raise ValueError(f"Invalid path. Describes a cycle.")
+            node = edge[1]
         return path_cost
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.15.1
+Version: 0.15.3
 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.1 → eqc_models-0.15.3}/eqc_models.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ eqc_models/utilities/fileio.py
 eqc_models/utilities/general.py
 eqc_models/utilities/polynomial.py
 eqc_models/utilities/qplib.py
+scripts/ALM_maxcut_demo.ipynb
 scripts/ALM_pipeline.ipynb
 scripts/binary_job_example.py
 scripts/binary_w_continuous_solver_example.py