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

{eqc_models-0.11.0.data → eqc_models-0.12.0.data}/platlib/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.12.0.data/platlib/eqc_models/base/results.py

@@ -0,0 +1,166 @@
+import dataclasses
+import warnings
+import numpy as np
+
+@dataclasses.dataclass
+class SolutionResults:
+    """
+    The class is meant to provide a uniform interface to results, no matter
+    the method of running the job. If available, the metrics are reported
+    in nanoseconds.
+
+    Properties
+    ------------
+
+    solutions : np.ndarray
+        2-d array of solution vectors
+
+    energies : np.ndarray
+        1-d array of energies computed from the device for each sample
+
+    counts : np.ndarray
+        1-d array of counts the particular sample occurred during sampling
+
+    objectives : np.ndarray
+        1-d array of objective values. Is None if the model does not provide
+        a separate objective function
+
+    run_time : np.ndarray
+        1-d array of runtimes reported by the device.
+
+    preprocessing_time : int
+        Single value for time spent preprocessing before sampling occurs.
+
+    postprocessing_time : np.ndarray
+        1-d array of time spent post-processing samples.
+
+    penalties : np.ndarray
+        1-d array of penalty values for each sample. Is None if the model does 
+        not have constraints.
+
+    device : str
+        String that represents the device used to solve the model.
+
+    time_units : str
+        String indicator of the unit of time reported in the metrics. Only
+        ns is supported at this time.
+
+    """
+
+    solutions : np.ndarray
+    energies : np.ndarray
+    counts : np.ndarray
+    objectives : np.ndarray
+    run_time : np.ndarray
+    preprocessing_time : int
+    postprocessing_time : np.ndarray
+    penalties : np.ndarray = None
+    device : str = None
+    time_units : str = "ns"
+
+    @property
+    def device_time(self) -> np.ndarray:
+        """ 
+        1-d array of device usage computed from preprocessing, runtime
+        and postprocessing time.
+
+        """
+        if self.run_time:
+            pre = self.preprocessing_time
+            runtime = np.sum(self.run_time)
+            post = np.sum(self.postprocessing_time)
+            return pre + runtime + post
+        else:
+            return None
+
+    @property
+    def total_samples(self):
+        return np.sum(self.counts)
+
+    @property
+    def best_energy(self):
+        return np.min(self.energies)
+
+    @classmethod
+    def determine_device_type(cls, device_config):
+        """ 
+        Use the device config object from a cloud response
+        to get the device info. It will have a device and job type
+        identifiers in it.
+
+        """
+        devices = [k for k in device_config.keys()]
+        # only one device type is supported at a time
+        return devices[0]
+
+    @classmethod
+    def from_cloud_response(cls, model, response, solver):
+        """ Fill in the details from the cloud """
+
+        solutions = np.array(response["results"]["solutions"])
+        if model.machine_slacks > 0:
+            solutions = solutions[:,:-model.machine_slacks]
+        energies = np.array(response["results"]["energies"])
+        # interrogate to determine the device type
+        try:
+            device_type = cls.determine_device_type(response["job_info"]["job_submission"]["device_config"])
+        except KeyError:
+            print(response.keys())
+            raise
+        if "dirac-1" in device_type:
+            # decode the qubo
+            new_solutions = []
+            for solution in solutions:
+                solution = np.array(solution)
+                # build an operator to map the bit vector to scalar
+                base_count = np.floor(np.log2(model.upper_bound))+1
+                assert np.sum(base_count) == solution.shape[0], "Incorrect solution-upper bound match"
+                m = model.upper_bound.shape[0]
+                n = solution.shape[0]
+                D = np.zeros((m, n), dtype=np.int32)
+                j = 0
+                for i in range(m):
+                    k = int(base_count[i])
+                    D[i, j:j+k] = 2**np.arange(k)
+                    j += k
+                solution = D@solution 
+                new_solutions.append(solution)
+            solutions = np.array(new_solutions)
+        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.array(response["results"]["counts"])
+        job_id = response["job_info"]["job_id"]
+        try:
+            metrics = solver.client.get_job_metrics(job_id=job_id)
+            metrics = metrics["job_metrics"]
+            time_ns = metrics["time_ns"]
+            device = time_ns["device"][device_type]
+            runtime = device["samples"]["runtime"]
+            post = device["samples"].get("postprocessing_time", [0 for t in runtime])
+            pre = device["samples"].get("preprocessing_time", 0)
+        except KeyError:
+            time_ns = []
+            runtime = []
+            post = []
+            pre = None
+        results = SolutionResults(solutions, energies, counts, objectives, 
+                                  runtime, pre, post, penalties=penalties,
+                                  device=device_type, time_units="ns")
+
+        return results

eqc_models-0.12.0.data/platlib/eqc_models/graph/__init__.py

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

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

@@ -0,0 +1,157 @@
+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)
+
+    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.info("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, (i, j) in enumerate(variables):
+            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.info("LHS shape %s RHS shape %s", _cons.shape, _rhs.shape)
+        log.info("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):
+            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
+
+        lhs, rhs = self.constraints
+        upper_thresh = max(solution)
+        lower_thresh = 0
+        while upper_thresh - lower_thresh > 1e-6:
+            log.info("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)
+            path = {}
+            try:
+                nx_path = nx.shortest_path(G, self.s, self.t)
+                upper_thresh = thresh
+                lower_thresh = thresh
+            except (nx.exception.NodeNotFound, nx.NetworkXAlgorithmError) as err:
+                lower_thresh = thresh
+        if nx_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
+

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

@@ -11,6 +11,7 @@ import numpy as np
 
 from eqc_models import QuadraticModel
 from eqc_models.solvers.qciclient import Dirac3CloudSolver
+from eqc_models.solvers.eqcdirect import Dirac3DirectSolver
 
 
 class ClassifierBase(QuadraticModel):
@@ -18,12 +19,25 @@ class ClassifierBase(QuadraticModel):
         self,
         relaxation_schedule=2,
         num_samples=1,
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,
     ):
 
         super(self).__init__(None, None, None)
         
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
+
+        assert solver_access in ["cloud", "direct"]
+
+        if solver_access == "direct":
+            assert ip_addr is not None, "ip_addr should be set when using direct solver!"
+            assert port is not None,"port should be set when using direct solver!"
+            
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port
         self.params = None
         self.X_train = None
         self.y_train = None
@@ -53,18 +67,30 @@ class ClassifierBase(QuadraticModel):
         return
 
     def solve(self):
-        solver = Dirac3CloudSolver()
+
+        if self.solver_access == "direct":
+            solver = Dirac3DirectSolver()
+            solver.connect(self.ip_addr, self.port)
+        else:
+            solver = Dirac3CloudSolver()
+            
         response = solver.solve(
             self,
             sum_constraint=self._sum_constraint,
             relaxation_schedule=self.relaxation_schedule,
-            solution_precision=1,
+            solution_precision=None,
             num_samples=self.num_samples,
         )
 
-        min_id = np.argmin(response["results"]["energies"])
-
-        sol = response["results"]["solutions"][min_id]
+        if self.solver_access == "cloud":
+            energies = response["results"]["energies"]
+            solutions = response["results"]["solutions"]
+        elif self.solver_access == "direct":
+            energies = response["energy"]
+            solutions = response["solution"]
+            
+        min_id = np.argmin(energies)
+        sol = solutions[min_id]
 
         print(response)
         

{eqc_models-0.11.0.data → eqc_models-0.12.0.data}/platlib/eqc_models/ml/classifierqboost.py

@@ -94,6 +94,12 @@ class QBoostClassifier(ClassifierBase):
 
     num_samples: Number of samples used by Dirac-3; default: 1.
 
+    solver_access: Solver access type: cloud or direct; default: cloud.
+
+    ip_addr: IP address of the device when direct access is used; default: None.
+    
+    port: Port number of the device when direct access is used; default: None.    
+    
     lambda_coef: A penalty multiplier; default: 0.
 
     weak_cls_schedule: Weak classifier schedule. Is either 1, 2,
@@ -155,6 +161,9 @@ class QBoostClassifier(ClassifierBase):
         self,
         relaxation_schedule=2,
         num_samples=1,
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,
         lambda_coef=0,
         weak_cls_schedule=2,
         weak_cls_type="lg",
@@ -172,9 +181,13 @@ class QBoostClassifier(ClassifierBase):
             "multi_processing_shm",
             "sequential",
         ]
-
+        assert solver_access in ["cloud", "direct"]
+        
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port
         self.lambda_coef = lambda_coef
         self.weak_cls_schedule = weak_cls_schedule
         self.weak_cls_type = weak_cls_type