eqc-models 0.11.1__tar.gz → 0.13.0__tar.gz

eqc_models-0.13.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__
+build
+eqc_models.egg-info
+
+*.c
+*.so

{eqc_models-0.11.1/eqc_models.egg-info → eqc_models-0.13.0}/PKG-INFO

@@ -1,9 +1,8 @@
 Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.11.1
+Version: 0.13.0
 Summary: Optimization and ML modeling package targeting EQC devices
-Author: Quantum Computing Inc.
-Author-email: support@quantumcomputinginc.com
+Author-email: "Quantum Computing Inc." <support@quantumcomputinginc.com>
 Project-URL: Homepage, https://quantumcomputinginc.com
 Project-URL: Documentation, https://quantumcomputinginc.com/learn/support/software-packages/
 Project-URL: Issues, https://support.quantumcomputinginc.com/
@@ -12,12 +11,11 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: numpy<2,>=1.22.1
 Requires-Dist: networkx<3,>=2.6.3
-Requires-Dist: pandas>=2.1.0
-Requires-Dist: scikit-learn>=1.2.1
-Requires-Dist: qci-client<5,>=4.3.0
-Requires-Dist: emucore-direct==1.0.6
-Provides-Extra: direct
-Requires-Dist: eqc-direct<2,>=1.3.0; extra == "direct"
+Requires-Dist: pandas<3,>=2.1.0
+Requires-Dist: scikit-learn<2,>=1.2.1
+Requires-Dist: qci-client<6,>=5
+Requires-Dist: emucore-direct==1.0.7
+Requires-Dist: eqc-direct==2.0.2
 Provides-Extra: dev
 Requires-Dist: pytest<8,>=7.1.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{eqc_models-0.11.1 → eqc_models-0.13.0}/eqc_models/base/base.py

@@ -41,6 +41,7 @@ class EqcModel:
     _upper_bound = None
     _H = None
     _machine_slacks = 0
+    _is_discrete = None
     
     def decode(self, solution : np.ndarray, from_encoding : str=None) -> np.ndarray:
         """ 
@@ -117,6 +118,16 @@ class EqcModel:
         warn("The domains property is deprecated in favor of naming it upper_bound", DeprecationWarning)
         self._upper_bound = value
 
+    @property
+    def is_discrete(self) -> List:
+        """ An array of boolean values indicating if variable should be restricted to a discrete domain """
+
+        return self._is_discrete
+
+    @is_discrete.setter
+    def is_discrete(self, value : List):
+        self._is_discrete = value
+
     @property
     def n(self) -> int:
         """ Return the number of variables """

eqc_models-0.13.0/eqc_models/base/binaries.py

@@ -0,0 +1,33 @@
+
+def make_binary_penalty(var_idx, slack_idx, max_degree=2, penalty_multiplier=None):
+    """ 
+    Make a penalty expression enforcing binary values 
+
+    The expression is formed from the conditions
+
+    $$
+    x + w = 1
+    $$
+
+    $$
+    xw = 0
+    $$
+
+    $$
+    w^2 + 2xw + x^2 - 2w - 2x + 1 + xw = 0
+    $$
+
+    $$
+    3xw + w^2 + x^2 - 2w - 2x + 1 = 0
+    $$
+
+    """
+
+    indices = [(0, var_idx), (0, slack_idx), (var_idx, slack_idx), (var_idx, var_idx), (slack_idx, slack_idx)]
+    coefficients = [-2, -2, 3, 1, 1]
+    offset = 1
+    if penalty_multiplier is not None:
+        coefficients = [penalty_multiplier * c for c in coefficients]
+        offset *- penalty_multiplier
+    return coefficients, indices, offset
+

{eqc_models-0.11.1 → eqc_models-0.13.0}/eqc_models/base/constraints.py

@@ -82,6 +82,45 @@ class ConstraintsMixIn:
     def constraints(self, value: Tuple[np.ndarray, np.ndarray]):
         self.lhs, self.rhs = value
 
+    @staticmethod
+    def _stackLHS(*args):
+        """
+
+        >>> m1 = np.array([1, 1, 1])
+        >>> m2 = np.array([[2.0, 2.0]])
+        >>> m3 = np.array([[0, 3, 3, 1], [1, 0, 1, 0]])
+        >>> ConstraintsMixIn._stackLHS(m1, m2, m3)
+        array([[1., 1., 1., 0.],
+               [2., 2., 0., 0.],
+               [0., 3., 3., 1.],
+               [1., 0., 1., 0.]])
+
+        """
+        n = 0
+        m = 0
+        dtype = np.int32
+        def update_dtype(matrix):
+            type_rank = ["int8", "int16", "int32", "int64", "float8", "float16", "float32", "float64"]
+            try:
+                idx = type_rank.index(str(matrix.dtype))
+            except ValueError:
+                raise TypeError(f"matrix type {matrix.dtype} not supported")
+        new_args = []
+        for mat in args:
+            if len(mat.shape) == 1:
+                mat = mat.reshape((1, mat.size))
+            if mat.shape[1] > n:
+                n = mat.shape[1]
+            m += mat.shape[0]
+            dtype = update_dtype(mat)
+            new_args.append(mat)
+        new_lhs = np.zeros((m, n), dtype=dtype)
+        idx = 0
+        for mat in new_args:
+            new_lhs[idx:idx+mat.shape[0],:mat.shape[1]] = mat
+            idx += mat.shape[0]
+        return new_lhs
+
     @property
     def offset(self) -> float:
         """ Calculate the offset due to the conversion of constraints to penalties """

{eqc_models-0.11.1 → eqc_models-0.13.0}/eqc_models/base/polynomial.py

@@ -1,10 +1,13 @@
 # (C) Quantum Computing Inc., 2024.
 from typing import Tuple, Union, List
+import logging
 import numpy as np
 from eqc_models.base.base import EqcModel
 from eqc_models.base.operators import Polynomial, QUBO, OperatorNotAvailableError
 from eqc_models.base.constraints import ConstraintsMixIn
 
+log = logging.getLogger(name=__name__)
+
 class PolynomialMixin:
     """This class provides an instance method and property that
     manage polynomial models.
@@ -46,7 +49,12 @@ class PolynomialMixin:
 
         """
 
-        value = self.polynomial.evaluate(np.array(solution))
+        coefficients, indices = self.H
+        log.debug("Coefficients (%d): %s", len(coefficients), coefficients)
+        log.debug("Indices (%d): %s", len(indices), indices)
+        polynomial = self.polynomial
+        log.debug("Polynomial: %s", polynomial)
+        value = polynomial.evaluate(np.array(solution))
 
         return value
     
@@ -107,8 +115,19 @@ class PolynomialModel(PolynomialMixin, EqcModel):
     """
 
     def __init__(self, coefficients : Union[List, np.ndarray], indices : Union[List, np.ndarray]) -> None:
+        # ensure that the coefficients are ordered and not duplicated
+        new_coefficients = {}
+        for idx, v in zip(indices, coefficients):
+            idx = tuple(idx)
+            if idx in new_coefficients:
+                new_coefficients[idx] += v
+            else:
+                new_coefficients[idx] = v
+        new_indices = [idx for idx in new_coefficients]
+        new_indices.sort()
+        coefficients = [new_coefficients[idx] for idx in new_indices]
         self.coefficients = coefficients
-        self.indices = indices
+        self.indices = new_indices
 
     @property
     def polynomial(self) -> Polynomial:

{eqc_models-0.11.1 → eqc_models-0.13.0}/eqc_models/base/quadratic.py

@@ -245,6 +245,6 @@ class ConstrainedQuadraticModel(ConstraintsMixIn, QuadraticModel):
         return self.lhs, self.rhs
     
     def evaluateObjective(self, solution: np.ndarray) -> float:
-        J = self.quad_objective
-        C = self.linear_objective
+        J = np.array(self.quad_objective)
+        C = np.array(self.linear_objective)
         return np.squeeze(C.T @ solution + solution.T@J@solution)

{eqc_models-0.11.1 → eqc_models-0.13.0}/eqc_models/base/results.py

@@ -1,4 +1,5 @@
 import dataclasses
+from typing import Dict
 import warnings
 import numpy as np
 
@@ -41,6 +42,14 @@ class SolutionResults:
     device : str
         String that represents the device used to solve the model.
 
+    raw_solutions : np.ndarray
+        Numpy array of the solutions as returned by the solver device.
+
+    calibration_time : float
+        Total time spend during job exectution where the device performed calibration.
+        The calibration is not directly affected by the job submission and the time
+        is not included in run_time.
+
     time_units : str
         String indicator of the unit of time reported in the metrics. Only
         ns is supported at this time.
@@ -56,6 +65,7 @@ class SolutionResults:
     postprocessing_time : np.ndarray
     penalties : np.ndarray = None
     device : str = None
+    raw_solutions : np.ndarray = None
     time_units : str = "ns"
 
     @property
@@ -95,7 +105,22 @@ class SolutionResults:
 
     @classmethod
     def from_cloud_response(cls, model, response, solver):
-        """ Fill in the details from the cloud """
+        """ 
+        Fill in the details from the cloud 
+
+        Parameters
+        ------------
+
+        model : eqc_models.base.EqcModel
+            EqcModel object describing the problem solved in response
+
+        response : Dict
+            Dictionary of the repsonse from the solver device.
+
+        solver : eqc_models.base.ModelSolver
+            ModelSolver object which is used to obtain job metrics.
+
+        """
 
         solutions = np.array(response["results"]["solutions"])
         if model.machine_slacks > 0:
@@ -164,3 +189,58 @@ class SolutionResults:
                                   device=device_type, time_units="ns")
 
         return results
+
+    @classmethod
+    def from_eqcdirect_response(cls, model, response, solver):
+        """
+        Fill in details from the response dictionary and possibly the solver device.
+
+        Parameters
+        ------------
+
+        model : eqc_models.base.EqcModel
+            EqcModel object describing the problem solved in response
+
+        response : Dict
+            Dictionary of the repsonse from the solver device.
+
+        solver : eqc_models.base.ModelSolver
+            ModelSolver object which is used to obtain device information. 
+
+        """
+        solutions = np.array(response["solution"])
+        if model.machine_slacks > 0:
+            solutions = solutions[:,:-model.machine_slacks]
+        energies = np.array(response["energy"])
+        # interrogate to determine the device type
+        info_dict = solver.client.system_info()
+        device_type = info_dict["device_type"]
+        if hasattr(model, "evaluateObjective"):
+            objectives = np.zeros((solutions.shape[0],), dtype=np.float32)
+            for i in range(solutions.shape[0]):
+                try:
+                    objective = model.evaluateObjective(solutions[i])
+                except NotImplementedError:
+                    warnings.warn(f"Cannot set objective value in results for {model.__class__}")
+                    objectives = None
+                    break
+                objectives[i] = objective
+        else:
+            objectives = None
+        if hasattr(model, "evaluatePenalties"):
+            penalties = np.zeros((solutions.shape[0],), dtype=np.float32)
+            for i in range(solutions.shape[0]):
+                penalties[i] = model.evaluatePenalties(solutions[i]) + model.offset
+        else:
+            penalties = None
+        counts = np.ones(solutions.shape[0])
+        runtime = response["runtime"]
+        post = response["postprocessing_time"]
+        pre = response["preprocessing_time"]
+        results = SolutionResults(solutions, energies, counts, objectives, 
+                                  runtime, pre, post, penalties=penalties,
+                                  device=device_type, time_units="s")
+
+        return results
+
+

eqc_models-0.13.0/eqc_models/graph/__init__.py

@@ -0,0 +1,11 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .base import EdgeMixin, EdgeModel, GraphModel, NodeModel
+from .maxcut import MaxCutModel
+from .partition import GraphPartitionModel
+from .shortestpath import ShortestPathModel
+from .rcshortestpath import RCShortestPathModel
+
+__all__ = ["MaxCutModel", "GraphPartitionModel",
+           "EdgeMixin", "EdgeModel", "GraphModel", 
+           "NodeModel"]

{eqc_models-0.11.1 → eqc_models-0.13.0}/eqc_models/graph/base.py

@@ -7,7 +7,7 @@ class GraphModel(QuadraticModel):
     """ """
     def __init__(self, G : nx.Graph):
         self.G = G
-        super().__init__(*self.costFunction())
+        super(GraphModel, self).__init__(*self.costFunction())
 
     @property
     def linear_objective(self):
@@ -63,12 +63,16 @@ class TwoPartitionModel(NodeModel):
     
     """
 
-class EdgeModel(GraphModel):
-    """ Create a model where the variables are edge-based """
+class EdgeMixin:
 
     @property
     def variables(self) -> List[str]:
         """ Provide a variable name to index lookup; order enforced by sorting the list before returning """
-        names = [f"({u},{v})" for u, v in self.G.edges]
+        names = [(u, v) for u, v in self.G.edges]
         names.sort()
         return names
+
+class EdgeModel(EdgeMixin, GraphModel):
+    """ Create a model where the variables are edge-based """
+
+    

eqc_models-0.13.0/eqc_models/graph/rcshortestpath.py

@@ -0,0 +1,81 @@
+import logging
+from typing import (Any, Dict, Tuple, List)
+import networkx as nx
+import numpy as np
+from eqc_models.graph.shortestpath import ShortestPathModel
+
+log = logging.getLogger(name=__name__)
+
+class RCShortestPathModel(ShortestPathModel):
+    """ 
+    Model for resource constrained shortest path problems.
+    Use a shortest path base model to implement the routing 
+    constraints and objective function. Add resource constraints.
+    
+    """
+
+    def __init__(self, G : nx.DiGraph, s : Any, t : Any, T : int, resource_key : str="resource"):
+        if T <= 0:
+            raise ValueError("T must be positive")
+        elif round(T, 0) != T:
+            raise ValueError("T must be integer-valued")
+        self.T = T
+        self.resource_key = resource_key
+        # determine shortest path by weight
+        nx_path = nx.shortest_path(G, s, t)
+        path_length = len(nx_path)
+        self.resource_mult = resource_mult = 2 * path_length / self.T
+        super(RCShortestPathModel, self).__init__(G, s, t)
+        upper_bound = np.ones(len(self.variables))
+        upper_bound[-1] = np.ceil(resource_mult * T)
+        self.upper_bound = upper_bound
+        is_discrete = [True for i in range(upper_bound.shape[0])]
+        is_discrete[-1] = False
+        self.is_discrete = is_discrete
+
+    @property
+    def variables(self):
+        variables = super(RCShortestPathModel, self).variables
+        return variables + ["resource_slack"]
+
+    def buildConstraints(self) -> Tuple[np.ndarray,np.ndarray]:
+        lhs, rhs = super(RCShortestPathModel, self).buildConstraints()
+        # add a single constraint
+        G = self.G
+        n = len(self.variables)
+        resource_lhs = np.zeros((1, n), dtype=np.float32)
+        resource_mult = self.resource_mult
+        log.debug("Resource multiplier %f", resource_mult)
+        for i in range(len(G.edges)):
+            (u, v) = self.variables[i]
+            # find the time to traverse the arc
+            resource_cost = G.edges[(u, v)][self.resource_key]
+            resource_cost *= resource_mult
+            log.debug(f"Adding resource %s for edge %s", resource_cost, (u, v))
+            resource_lhs[0, i] = resource_cost
+        resource_lhs[0, -1] = 1
+        lhs = self._stackLHS(lhs, resource_lhs)
+        rhs = np.hstack([rhs, [self.T*resource_mult]])
+        log.debug("LHS shape %s RHS shape %s", lhs.shape, rhs.shape)
+        return lhs, rhs
+
+    def pathCost(self, path):
+        """ sum the cost of all legs in the path """
+        assert self.s in path
+        G = self.G
+        node = self.s
+        max_len = len(self.G.nodes) - 1
+        path_len = 0
+        path_cost = 0
+        path_resources = 0
+        while node != t:
+            edge = (node, path[node])
+            if edge not in G.edges:
+                raise ValueError(f"Edge {edge} not found")
+            path_len += 1
+            path_cost += G.edges[edge]["weight"]
+            path_resources += G.edges[edge][self.resource_key]
+            if path_len > max_len:
+                raise ValueError("Invalid path. Describes a cycle.")
+        return path_cost, path_resources
+

eqc_models-0.13.0/eqc_models/graph/shortestpath.py

@@ -0,0 +1,190 @@
+r"""
+MIP Shortest Path implementation
+
+Given a graph $G$ and nodes $s$ and $t$, find the shortest path
+by edge weight between $s$ and $t$. 
+
+$$
+\min sum_ij w_ij x_ij
+$$
+subject to
+$$
+\sum_{(u,v)\in E} x_{u,v} - \sum{(v,u)\in E} x_{v,u} = 0 \forall u\in N\\{s,t}
+$$
+and
+$$
+\sum_{(s,v)\in E} x_{s,v} = 1
+$$
+and
+$$
+\sum_{(u,t)\in E} x_{u,t} = 1
+$$
+
+"""
+
+from typing import Any, Dict, Tuple
+import logging
+import numpy as np
+import networkx as nx
+from eqc_models.graph import EdgeMixin
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
+
+log = logging.getLogger(name=__name__)
+
+class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
+    """
+    ShortestPathModel describes the MIP formulation for the 
+    shortest path problem.
+
+    Parameters
+    -------------
+
+    G : nx.DiGraph
+        A directed graph which is assumed to be connected. A graph
+        with disconnected subgraphs may reveal a solution if $s$ and $t$
+        are in the same subgraph, but testing for the existence of a path
+        between s and t using this model is not recommended. This is 
+        due to the difficulty posed by selecting a penalty multiplier 
+        large enough to enforce the panalties, which DNE in the infeasible 
+        case.
+    s : Any
+        This is the label for the start node.
+    t : Any
+        This is the label for the end node.
+
+
+    """
+
+    def __init__(self, G: nx.DiGraph, s : Any, t : Any):
+        self.G = G
+        self.s = s
+        self.t = t
+        self.lhs, self.rhs = self.buildConstraints()
+        C, J = self.buildObjective()
+        super(ShortestPathModel, self).__init__(C, J, self.lhs, self.rhs)
+        self.upper_bound = np.ones(self.lhs.shape[1])
+        self.is_discrete = [True for i in range(self.lhs.shape[1])]
+        self.machine_slacks = 0
+
+    def buildConstraints(self) -> Tuple[np.ndarray,np.ndarray]:
+        """
+        Constraints: 
+        $$
+        sum_j x[i,l] - sum_j x[j,l] = c for all l
+        $$
+        $c$ is -1, 1 or 0 for $i=t$, $s$ or all others
+        
+        """
+        log.debug("Building constraints to find path from %s to %s", self.s, self.t)
+        variables = self.variables
+        nodes = [n for n in self.G.nodes]
+        m = len(nodes)
+        n = len(variables)
+        _cons = np.zeros((m, n), dtype=np.int8)
+        _rhs = np.zeros((m, 1), dtype=np.int8)
+        for node_index, k in enumerate(nodes):
+            if k == self.s:
+                _rhs[node_index, 0] = 1
+            elif k == self.t:
+                _rhs[node_index, 0] = -1
+        for l in range(len(self.G.edges)): # don't enumerate the edges because the order could change
+            (i, j) = self.variables[l]
+            if i == j:
+                # self loops are not allowed
+                raise ValueError("Self loops are not allowed in ShortestPathModel")
+            # # ignore these edges because we can't go back to s or leave t
+            elif j == self.s:
+                continue
+            elif i == self.t:
+                continue
+            i_index = nodes.index(i)
+            j_index = nodes.index(j)
+            _cons[i_index, l] = 1
+            _cons[j_index, l] = -1
+        log.debug("LHS shape %s RHS shape %s", _cons.shape, _rhs.shape)
+        log.debug("checksum %f min %f", np.sum(_cons), np.min(_cons))
+        assert np.sum(_rhs) == 0
+        return _cons, np.squeeze(_rhs)
+
+    def buildObjective(self) -> Tuple[np.ndarray, np.ndarray]:
+        r"""
+        Objective:
+        $\min sum_ij w_ij x_ij$
+
+        """
+        variables = self.variables
+        G = self.G
+        nodes = G.nodes
+        m, n = len(nodes), len(variables)
+        _obj = [0 for i in range(n)]
+        for index, name in enumerate(variables):
+            if type(name) == type((1,2)):
+                i, j = name
+                _obj[index] = v = G.get_edge_data(i, j)["weight"]
+                assert not np.isnan(v), f"Got a NaN at {i, j}"
+        J = np.zeros((n, n))
+        return np.array(_obj), J
+
+    def decode(self, solution : np.ndarray) -> Dict:
+        """ 
+        Convert a solution to this model into a path, which is
+        a dictionary with each edge described by key, value pairs.
+
+        """
+        variables = self.variables[:len(self.G.edges)]
+        # log.debug("Using variables %s", variables)
+
+        lhs, rhs = self.constraints
+        log.debug("LHS shape %s RHS shape %s", lhs.shape, rhs.shape)
+        upper_thresh = max(solution[:len(variables)])
+        lower_thresh = 0
+        got_path = None
+        while upper_thresh - lower_thresh > 1e-6:
+            log.debug("Lower Value: %f Upper Value %f", lower_thresh, upper_thresh)
+            thresh = (lower_thresh + upper_thresh) / 2
+            nx_path = None
+            G = nx.DiGraph()
+            for (i, j), value in zip(variables, solution):
+                if value > thresh:
+                    G.add_edge(i, j)
+            edges = [e for e in G.edges]
+            log.debug("Resulting edge count %s", len(edges))
+            self.alt_g = G
+            path = {}
+            try:
+                nx_path = nx.shortest_path(G, self.s, self.t)
+                lower_thresh = thresh
+                got_path = nx_path
+                log.debug("Got path size %d", len(got_path))
+            except (nx.exception.NodeNotFound, nx.NetworkXAlgorithmError) as err:
+                upper_thresh = thresh
+        if got_path is None:
+            raise RuntimeError(f"Solution does not describe path from {self.s} to {self.t}")
+        # path = {}
+        # log.debug("Translating path to dictionary")
+        # for i, v in enumerate(got_path):
+        #     path[got_path[i-1]] = v
+        # log.debug("Updated path %s", path)
+        # if self.t in path:
+        #     log.debug("Removing %s from path keys.", self.t)
+        #     del path[self.t]
+        return got_path
+
+    def pathCost(self, path):
+        """ sum the cost of all legs in the path """
+        assert self.s in path
+        G = self.G
+        node = self.s
+        max_len = len(self.G.nodes) - 1
+        path_len = 0
+        path_cost = 0
+        while node != t:
+            edge = (node, path[node])
+            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.")
+        return path_cost
+