eqc-models 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/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.12.0.data → eqc_models-0.13.0.data}/platlib/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.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/graph/__init__.py

@@ -3,6 +3,8 @@
 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", 

eqc_models-0.13.0.data/platlib/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.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/graph/shortestpath.py

@@ -62,6 +62,9 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
         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]:
         """
@@ -72,7 +75,7 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
         $c$ is -1, 1 or 0 for $i=t$, $s$ or all others
         
         """
-        log.info("Building constraints to find path from %s to %s", self.s, self.t)
+        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)
@@ -84,7 +87,8 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
                 _rhs[node_index, 0] = 1
             elif k == self.t:
                 _rhs[node_index, 0] = -1
-        for l, (i, j) in enumerate(variables):
+        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")
@@ -97,8 +101,8 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
             j_index = nodes.index(j)
             _cons[i_index, l] = 1
             _cons[j_index, l] = -1
-        log.info("LHS shape %s RHS shape %s", _cons.shape, _rhs.shape)
-        log.info("checksum %f min %f", np.sum(_cons), np.min(_cons))
+        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)
 
@@ -114,9 +118,10 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
         m, n = len(nodes), len(variables)
         _obj = [0 for i in range(n)]
         for index, name in enumerate(variables):
-            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}"
+            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
 
@@ -126,32 +131,60 @@ class ShortestPathModel(EdgeMixin, ConstrainedQuadraticModel):
         a dictionary with each edge described by key, value pairs.
 
         """
-        variables = self.variables
+        variables = self.variables[:len(self.G.edges)]
+        # log.debug("Using variables %s", variables)
 
         lhs, rhs = self.constraints
-        upper_thresh = max(solution)
+        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.info("Lower Value: %f Upper Value %f", lower_thresh, upper_thresh)
+            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)
-                upper_thresh = thresh
                 lower_thresh = thresh
+                got_path = nx_path
+                log.debug("Got path size %d", len(got_path))
             except (nx.exception.NodeNotFound, nx.NetworkXAlgorithmError) as err:
-                lower_thresh = thresh
-        if nx_path is None:
+                upper_thresh = thresh
+        if got_path is None:
             raise RuntimeError(f"Solution does not describe path from {self.s} to {self.t}")
-        path = {}
-        for i, v in enumerate(nx_path):
-            path[nx_path[i-1]] = v
-        if self.t in path:
-            del path[self.t]
-        return path
+        # 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
 

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/ml/classifierbase.py

@@ -78,7 +78,6 @@ class ClassifierBase(QuadraticModel):
             self,
             sum_constraint=self._sum_constraint,
             relaxation_schedule=self.relaxation_schedule,
-            solution_precision=None,
             num_samples=self.num_samples,
         )
 

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/ml/clusteringbase.py

@@ -68,7 +68,6 @@ class ClusteringBase(QuadraticModel):
                 self,
                 sum_constraint=self._sum_constraint,
                 relaxation_schedule=self.relaxation_schedule,
-                solution_precision=1,
                 num_samples=self.num_samples,
             )
 

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/ml/decomposition.py

@@ -66,7 +66,6 @@ class DecompBase(QuadraticModel):
         response = solver.solve(
             self,
             relaxation_schedule=self.relaxation_schedule,
-            solution_precision=1,
             sum_constraint=self._sum_constraint,
             num_samples=self.num_samples,
         )

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/ml/regressorbase.py

@@ -56,7 +56,6 @@ class RegressorBase(QuadraticModel):
             self,
             sum_constraint=self._sum_constraint,
             relaxation_schedule=self.relaxation_schedule,
-            solution_precision=1,
             num_samples=self.num_samples,
         )
 

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/solvers/__init__.py

@@ -2,7 +2,15 @@
 from .eqcdirect import Dirac3DirectSolver
 from .qciclient import (Dirac1CloudSolver, Dirac3CloudSolver, QciClientSolver,
                         Dirac3IntegerCloudSolver, Dirac3ContinuousCloudSolver)
+from .mip import MIPMixin
+
+class Dirac3MIPCloudSolver(MIPMixin, Dirac3ContinuousCloudSolver):
+    pass
+
+class Dirac3MIPDirectSolver(MIPMixin, Dirac3DirectSolver):
+    pass
 
 __all__ = ["Dirac3DirectSolver", "Dirac1CloudSolver", "Dirac3CloudSolver", 
            "EqcDirectSolver", "QciClientSolver", "Dirac3IntegerCloudSolver",
-           "Dirac3ContinuousCloudSolver"]
+           "Dirac3ContinuousCloudSolver", "MILPMixin",
+           "Dirac3MIPCloudSolver", "Dirac3MIPDirectSolver"]

{eqc_models-0.12.0.data → eqc_models-0.13.0.data}/platlib/eqc_models/solvers/eqcdirect.py

@@ -1,8 +1,9 @@
 # (C) Quantum Computing Inc., 2025.
 import logging
 import numpy as np
+from typing import Dict
 from eqc_direct.client import EqcClient
-from eqc_models.base.base import ModelSolver
+from eqc_models.base.base import EqcModel, ModelSolver
 from eqc_models.base.results import SolutionResults
 
 log = logging.getLogger(name=__name__)
@@ -19,7 +20,6 @@ class Dirac3DirectSolver(ModelSolver):
         sum_constraint,
         relaxation_schedule=1,
         num_samples=1,
-        solution_precision=None,
         mean_photon_number=None,
         quantum_fluctuation_coefficient=None,
     ):
@@ -30,7 +30,8 @@ class Dirac3DirectSolver(ModelSolver):
         for i in range(len(indices)):
             if max(indices[i]) > num_variables:
                 num_variables = max(indices[i])
-
+        # add machine slacks
+        num_variables += model.machine_slacks
         print("Num variables:", num_variables)
 
         client = self.client
@@ -49,7 +50,6 @@ class Dirac3DirectSolver(ModelSolver):
                 lock_id=lock_id,
                 relaxation_schedule=relaxation_schedule,
                 sum_constraint=sum_constraint,
-                solution_precision=solution_precision,
                 mean_photon_number=mean_photon_number,
                 quantum_fluctuation_coefficient=quantum_fluctuation_coefficient,
             )
@@ -69,3 +69,8 @@ class Dirac3DirectSolver(ModelSolver):
     @property
     def client(self) -> EqcClient:
         return EqcClient(self.ip_addr, self.port, cert_file=self.cert_file)
+
+    def makeResults(self, model : EqcModel, response : Dict):
+        """ Builds the results object """
+
+        return SolutionResults.from_eqcdirect_response(model, response, self)

eqc_models-0.13.0.data/platlib/eqc_models/solvers/mip.py

@@ -0,0 +1,115 @@
+import logging
+import numpy as np
+from eqc_models.base.base import EqcModel
+from eqc_models.base.binaries import make_binary_penalty
+from eqc_models.base.polynomial import PolynomialModel
+
+log = logging.getLogger(name=__name__)
+
+class MIPMixin:
+    """
+    Implements a solve method which intercepts the operator and builds a new
+    model with added terms for restriction of discrete variables with an 
+    upper bound of 1 to take on only values 0 or 1 at minima.
+
+    Following the submission of a new model with the added penalties,
+    the solutions are updated to exclude added slack variables.
+
+    This is only supported with continuous-capable devices.
+
+    """
+
+    def solve(self, model : EqcModel, *args, **kwargs):
+        if model.is_discrete is None:
+            raise ValueError("Model solved with an MIP solver must have certain variables labeled discrete")
+        elif len([b for b in model.is_discrete if b])==0:
+            raise ValueError("Model solved with an MIP solver must have certain variables labeled discrete")
+        if kwargs.get("sum_constraint", None) is None:
+            raise ValueError("sum_constraint must be specified for MIP model sampling")
+        # get a polynomial
+        poly = model.polynomial
+        if hasattr(poly.coefficients, "tolist"):
+            coefficients = poly.coefficients.tolist()
+        else:
+            coefficients = list(poly.coefficients)
+        indices = poly.indices
+        old_n = model.n
+        log.debug("Model coefficients %d", len(coefficients))
+        log.debug("Model indices %d", len(indices))
+        log.debug("Model size %d", old_n)
+        if "penalty_multiplier" in kwargs:
+            penalty_multiplier = kwargs["penalty_multiplier"]
+            del kwargs["penalty_multiplier"]
+        else:
+            penalty_multiplier = getattr(model, "penalty_multiplier", 1)
+        log.debug("Binary enforcement penalty multiplier %f", penalty_multiplier)
+        bin_slacks = []
+        offset = 0
+        variables = model.variables
+        addtl_upper_bound = []
+        for i, v in enumerate(model.variables):
+            if model.is_discrete[i]:
+                bin_slacks.append(f"bin_slacks_{v}")
+                penalty_coeff, penalty_indices, penalty_offset = make_binary_penalty(i+1, len(variables)+len(bin_slacks), penalty_multiplier=penalty_multiplier)
+                log.debug("Adding penalties coeff: %s indices %s offset %s", penalty_coeff, penalty_indices, penalty_offset)
+                coefficients += penalty_coeff
+                indices += penalty_indices
+                offset += penalty_offset
+                addtl_upper_bound.append(1)
+                assert len(coefficients) == len(indices)
+        variables = variables + bin_slacks
+        log.debug("New model binary penalty slacks: %s", bin_slacks)
+        new_model = PolynomialModel(coefficients, indices)
+        new_model.variables = variables
+        log.debug("New model variables: %s", variables)
+        new_model.upper_bound = np.array(model.upper_bound.tolist() + addtl_upper_bound)
+        new_model.machine_slacks = model.machine_slacks
+        coefficients, indices = new_model.H
+        log.debug("New model coefficients %d", len(coefficients))
+        log.debug("New model indices %d", len(indices))
+        log.debug("New model size: %d", new_model.n)
+        response = super().solve(new_model, *args, **kwargs)
+        # translate the response into results
+        results = self.makeResults(new_model, response)
+        log.debug(results)
+        # update the results to relect the original model
+        solutions = results.solutions
+        for i in range(len(solutions)):
+            log.debug("SolutionResults solution: %s", solutions[i])
+        if hasattr(model, "evaluateObjective"):
+            new_objectives = []
+        else:
+            new_objectives = None
+        if hasattr(model, "evaluatePenalties"):
+            new_penalties = []
+        else:
+            new_penalties = None
+        new_solutions = []
+        new_energies = []
+        num_vars = len(solutions[0]) - len(bin_slacks)
+        log.debug("Num_vars %f", num_vars)
+        machine_slacks = model.machine_slacks
+        for i, solution in enumerate(solutions):
+            log.debug("%d - Raw solution %s", i, solution)
+            new_sol = [v for v in solution[:num_vars]]
+            new_sol = np.array(new_sol)
+            if machine_slacks > 0:
+                new_sol[-machine_slacks:] = solution[-machine_slacks:]
+            log.debug("%d - New solution %s", i, new_sol)
+            if new_objectives is not None:
+                try:
+                    new_objectives.append(model.evaluateObjective(new_sol))
+                except NotImplementedError as err:
+                    pass
+            if new_penalties is not None:
+                try:
+                    new_penalties.append(model.evaluatePenalties(new_sol))
+                except NotImplementedError as err:
+                    pass
+            new_solutions.append(new_sol)
+            new_energies.append(model.evaluate(new_sol))
+        results.solutions = new_solutions
+        results.penalties = new_penalties
+        results.objectives = new_objectives
+        results.energies = new_energies
+        return results