eqc-models 0.10.0__tar.gz → 0.10.2__tar.gz

{eqc_models-0.10.0/eqc_models.egg-info → eqc_models-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: eqc-models
-Version: 0.10.0
+Version: 0.10.2
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com

{eqc_models-0.10.0 → eqc_models-0.10.2}/docs/source/dependencies.rst

@@ -9,5 +9,6 @@ Packages
 - ``numpy>=1.22.1, <2``
 - ``networkx>=2.6.3, <3``
 - ``pandas>=2.1.0``
+- ``scikit-learn>=1.2.1``
 - ``qci-client>=4.3.0, <5``
 - ``emucore-direct==1.0.6``

{eqc_models-0.10.0 → eqc_models-0.10.2}/docs/source/eqc_models.rst

@@ -38,6 +38,14 @@ eqc\_models.assignment
    :undoc-members:
    :show-inheritance:
 
+eqc\_models.combinatorics
+--------------------------
+
+.. automodule:: eqc_models.combinatorics
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 eqc\_models.graph
 --------------------
 

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/__init__.py

@@ -8,8 +8,9 @@ from .base import QuadraticModel, PolynomialModel
 from .solvers import (Dirac1CloudSolver, Dirac3CloudSolver, Dirac3DirectSolver)
 from .allocation import AllocationModel, AllocationModelX, ResourceRuleEnum
 from .assignment import QAPModel
+from .combinatorics import SetCoverModel, SetPartitionModel
 
 __all__ = ["QuadraticModel", "PolynomialModel", "Dirac1CloudSolver", 
            "Dirac3CloudSolver", "AllocationModel", "AllocationModelX",
            "Dirac3DirectSolver", "ResourceRuleEnum",
-           "QAPModel"]
+           "QAPModel", "SetPartitionModel", "SetCoverModel"]

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/algorithms/penaltymultiplier.py

@@ -33,6 +33,14 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     penalties : List
         The values for penalties found at each algorithm iteration. A penalty of 0
         indicates algorithm termination.
+    penalty_threshold : float
+        This value is the cutoff for penalty values that are threated as 0. Default
+        is 1e-6. 
+    progress_threshold : float
+        This value is the cutoff for checking for progress on reducing the penalty
+        value. The current penalty is compared to the average of the previous two
+        and if the absolute difference is less than this value, then the algorithm
+        stops, reporting progress has not been made. The default value is 1e-4.
     dynamic_range : List
         The values for the dynamic range of the unconstrained problem formulation,
         which is useful for identifying difficulty in representation of the problem
@@ -50,7 +58,7 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     This example uses the quadratic assignment problem and the known multiplier to test 
     the implementation of the algorithm.
 
-    >>> from eqc_models.solvers.qciclient import Dirac3CloudSolver
+    >>> from eqc_models.solvers.qciclient import Dirac3IntegerCloudSolver
     >>> from eqc_models.assignment.qap import QAPModel
     >>> A = np.array([[0, 5, 8, 0, 1],
     ...               [0, 0, 0, 10, 15],
@@ -68,10 +76,10 @@ class PenaltyMultiplierAlgorithm(Algorithm):
     ...               [7, 5, 8, 5, 7],
     ...               [1, 9, 2, 9, 2.]])
     >>> model = QAPModel(A, B, C)
-    >>> solver = Dirac3CloudSolver() # must be configured with environment variables
+    >>> solver = Dirac3IntegerCloudSolver() # must be configured with environment variables
     >>> algo = PenaltyMultiplierAlgorithm(model, solver)
     >>> algo.upper_bound = 330.64
-    >>> algo.run(relaxation_schedule=2, mean_photon_number=0.15, normalized_loss_rate=4, num_samples=5) # doctest: +ELLIPSIS
+    >>> algo.run(relaxation_schedule=2, num_samples=5) # doctest: +ELLIPSIS
     2... RUNNING... COMPLETED...
     >>> algo.alphas[-1] # doctest: +SKIP
     106.25
@@ -80,7 +88,8 @@ class PenaltyMultiplierAlgorithm(Algorithm):
  
     """
 
-    def __init__(self, model : ConstraintModel, solver : ModelSolver):
+    def __init__(self, model : ConstraintModel, solver : ModelSolver, penalty_threshold:float=1e-6,
+                 progress_threshold : float = 1e-4):
         self.model = model
         self.solver = solver
         # ub = np.max(model.quad_objective)
@@ -95,6 +104,8 @@ class PenaltyMultiplierAlgorithm(Algorithm):
         self.alphas = None
         self.dynamic_range = None
         self.responses = None
+        self.penalty_threshold = penalty_threshold
+        self.progress_threshold = progress_threshold
 
     @property
     def upper_bound(self) -> float:
@@ -141,7 +152,7 @@ class PenaltyMultiplierAlgorithm(Algorithm):
         else:
             penalty = None
             
-        while penalty is None or penalty > 1e-6:
+        while penalty is None or penalty > self.penalty_threshold:
             log.info("NEW RUN")
             log.info("SETTING MULTIPLIER %f", alpha)
             model.penalty_multiplier = float(alpha)
@@ -162,8 +173,10 @@ class PenaltyMultiplierAlgorithm(Algorithm):
             energies.append(results["energies"][0])
             log.info("NEW SOLUTION OBJECTIVE %f LESS OFFSET %f ENERGY %f PENALTY %f", 
                      obj_val, less_offset, energies[-1], penalty)
-            if obj_val < ub:
+            if penalty < self.penalty_threshold:
+                pass
+            elif obj_val < ub:
                 alpha += (ub - obj_val) / penalty
-            if abs(sum(penalties[-2:])/2-penalty) < 1e-4:
+            if penalty > self.penalty_threshold and abs(sum(penalties[-2:])/2-penalty) < self.progress_threshold:
                 log.warn("SUFFICIENT PROGRESS NOT MADE FOR THREE ITERATIONS, QUITTING")
                 break

eqc_models-0.10.2/eqc_models/assignment/setpartition.py

@@ -0,0 +1,4 @@
+from ..combinatorics import SetPartitionModel
+import warnings
+
+warnings.warn("import of SetPartitionModel through assignment is deprecated", DeprecationWarning)

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/base/base.py

@@ -42,12 +42,50 @@ class EqcModel:
     _H = None
     _machine_slacks = 0
     
-    def decode(self, solution : np.ndarray) -> np.ndarray:
-        """ Manipulate the solution to match the variable count """
+    def decode(self, solution : np.ndarray, from_encoding : str=None) -> np.ndarray:
+        """ 
+        Manipulate the solution to match the variable count. Optionally,
+        a log-encoded solution vector can be translated into a vector
+        with integral values.
+
+        Parameters
+        -----------
+
+        solution : np.ndarray
+            1d solution vector 
+
+        from_encoding : str
+            string indicating if the vector is an encoding of particular type. The
+            text 'qubo' is the only option that does anything for now.
+
+        >>> model = EqcModel()
+        >>> ub = np.array([1, 2, 5])
+        >>> model.upper_bound = ub
+        >>> model.machine_slacks = 1
+        >>> solution = np.array([1, 1, 1, 1, 0, 1, 0]) # this solution has a 3, which violates the upper bound, but decode doesn't care
+        >>> model.decode(solution, "qubo")
+        array([1, 3, 5])
+
+        """
         
+        solution = np.array(solution)
         # ignore any slacks that may have been added during encoding
-        solution = solution[:-self.machine_slacks]
-        
+        if self.machine_slacks > 0:
+            solution = solution[:-self.machine_slacks]
+        if from_encoding == "qubo":
+            ub = self.upper_bound
+            en = solution.shape[0]
+            assert en > 0
+            n = ub.shape[0]
+            linear_operator = np.zeros((n,en))
+            j = 0
+            for i in range(self.n):
+                m = int(np.floor(np.log2(ub[i]))+1)
+                bits = 2**np.arange(m)
+                assert j+m <= linear_operator.shape[1]+2, f"Invalid slice for i={i} {j}:{j+m}"
+                linear_operator[i,j:j+m] = bits
+                j += m
+            solution = (linear_operator@solution).astype(np.int64)
         return solution
 
     @property
@@ -64,6 +102,8 @@ class EqcModel:
         value = np.array(value)
         if (value != value.astype(np.int64)).any():
             raise ValueError("Upper bound values must be integer")
+        if (value==0).any():
+            raise ValueError("Zero values are not allowed as an upper_bound.")
         self._upper_bound = value.astype(np.int64)
 
     @property

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/base/polynomial.py

@@ -117,12 +117,15 @@ class PolynomialModel(PolynomialMixin, EqcModel):
 
     @property
     def qubo(self) -> QUBO:
+        polynomial = self.polynomial
+        coefficients = polynomial.coefficients
+        indices = polynomial.indices
         try:
-            if np.all([len(self.polynomial.indices[i]) == 2 for i in range(len(self.polynomial.indices))]):
+            if np.all([len(indices[i]) == 2 for i in range(len(indices))]):
                 bin_n = 0
                 bits = []
-                C, J = self._quadratic_polynomial_to_qubo_coefficients(self.polynomial.coefficients,
-                                                                       self.polynomial.indices, self.n)
+                C, J = self._quadratic_polynomial_to_qubo_coefficients(coefficients,
+                                                                       indices, self.n)
                 # upper_bound is an array of the maximum values each variable can take
                 upper_bound = self.upper_bound
                 if np.sum(upper_bound) != upper_bound.shape[0]:
@@ -158,6 +161,7 @@ class PolynomialModel(PolynomialMixin, EqcModel):
                 raise OperatorNotAvailableError("QUBO operator not available")
         except OperatorNotAvailableError as e:
             print(e)
+            raise
 
     def _quadratic_polynomial_to_qubo_coefficients(self, coefficients, indices, num_variables):
         """

eqc_models-0.10.2/eqc_models/combinatorics/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .setcover import SetCoverModel
+from .setpartition import SetPartitionModel
+
+__all__ = ["SetCoverModel", "SetPartitionModel"]

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/combinatorics/setcover.py

@@ -37,6 +37,7 @@ class SetCoverModel(ConstrainedQuadraticModel):
         List of weights where each weight is the cost of choosing the subset
         corresponding to the index of the weight.
 
+
     >>> X = [set(['A', 'B']), set(['B', 'C']), set(['C'])]
     >>> weights = [2, 2, 1]
     >>> model = SetCoverModel(X, weights)

{eqc_models-0.10.0/eqc_models/assignment → eqc_models-0.10.2/eqc_models/combinatorics}/setpartition.py

@@ -86,6 +86,8 @@ class SetPartitionModel(ConstrainedPolynomialModel):
         b = np.ones((A.shape[0],))
         n = A.shape[1]
 
+        self.upper_bound = np.ones((n,), np.int32)
+
         # Define the linear objective function based on subset weights
         self.linear_objective = np.array(weights).reshape((n, 1))
         self.quad_objective = np.zeros((n, n)) #np.zeros_like(J)

eqc_models-0.10.2/eqc_models/graph/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .maxcut import MaxCutModel
+from .partition import GraphPartitionModel
+
+__all__ = ["MaxCutModel", "GraphPartitionModel"]

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/graph/maxkcut.py

@@ -1,20 +1,24 @@
 # (C) Quantum Computing Inc., 2024.
+from typing import Tuple
 import numpy as np
 import networkx as nx
 from .base import NodeModel
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
 
-
-class MaxKCutModel(NodeModel):
+class MaxKCutModel(ConstrainedQuadraticModel):
+    _objective = None
 
     def __init__(self, G : nx.Graph, k : int):
-        super(MaxKCutModel, self).__init__(G)
+        self.G = G
         self.k = k
-        self.lhs = None
-        self.rhs = None
-        self._objective = None
-        self._J = None
-        self._C = None
-
+        A, b = self._build_constraints()
+        c, J = self.costFunction()
+        ConstrainedQuadraticModel.__init__(self, c, J, A, b)
+        if k < 3:
+            raise ValueError("k must be greater than 2")
+        n = len(G.nodes) * k
+        self.upper_bound = np.ones((n,))
+        
     def decode(self, solution: np.ndarray) -> np.ndarray:
         """ Override the default decoding to use a the max cut metric to determine a solution """
 
@@ -22,7 +26,8 @@ class MaxKCutModel(NodeModel):
         # rather than the same cutoff per node, use the max value per partition
         decoded_solution = np.zeros_like(solution, dtype=np.int32)
         k = self.k
-        for i, u in enumerate(self.variables):
+        G = self.G
+        for i, u in enumerate(G.nodes):
             idx = slice(k*i, k*(i+1))
             spins = solution[idx]
             mx = np.max(spins)
@@ -35,9 +40,9 @@ class MaxKCutModel(NodeModel):
     def partition(self, solution):
         """ Return a dictionary with the partition number of each node """
         k = self.k
-        n = len(self.variables)
+        G = self.G
         partition_num = {}
-        for i, u in enumerate(self.variables):
+        for i, u in enumerate(G.nodes):
             for j in range(k):
                 if solution[i*k+j] == 1:
                     partition_num[u] = j+1
@@ -50,10 +55,10 @@ class MaxKCutModel(NodeModel):
                 cut_size += 1
         return cut_size
 
-    def _build_objective(self):
+    def costFunction(self) -> Tuple:
         
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
         # construct the quadratic portion of the objective
@@ -70,12 +75,12 @@ class MaxKCutModel(NodeModel):
                 idx1 = ibase + incr1
                 idx2 = jbase + incr2
                 objective[idx1, idx2] += -1
-        self._objective = (np.zeros((n, 1)), objective)
+        return (np.zeros((n, 1)), objective)
 
     def _build_constraints(self):
 
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
 
@@ -86,78 +91,31 @@ class MaxKCutModel(NodeModel):
             i = node_map.index(u)
             ibase = i * self.k
             A[i, ibase:ibase+self.k] = 1
-        self.lhs = A
-        self.rhs = b
-
-    def build(self, multiplier=None):
-        """ Create the constraints and objective and Hamiltonian """
-
-        # there are k * m variables in this problem where m is the number of nodes in the graph
-        node_map = self.variables
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        self.upper_bound = np.ones((n,))
-        
-        self._build_objective()
-        if multiplier is None:
-            multiplier = np.max(np.abs(self._objective[1]))
-        self._build_constraints()
-
-        self._C, self._J = self.buildH(multiplier)
-        self.sum_constraint = m
-
-    def buildH(self, multiplier):
-        """ Combine the objective and penalties using the multiplier """
-
-        objC, objJ = self.objective
-        lhs, rhs = self.constraints
-        Pq = lhs.T@lhs
-        Pl = -2 * rhs.T@lhs
-        offset = rhs.T@rhs
-        n = self.n
-        J = np.zeros((n, n), np.float32)
-        C = np.zeros([n, 1], np.float32)
-        C += objC
-        J[:,:] += objJ
-        C += multiplier * Pl.reshape((n, 1))
-        J[:,:] += multiplier * Pq
-        return C, J
+        return A, b
 
     @property
     def constraints(self):
         """ Return LHS, RHS in numpy matrix format """
-        if self.rhs is None:
-            self.build()
+
         return self.lhs, self.rhs
 
     @property
     def objective(self):
         """ Return the quadratic objective as NxN+1 matrix """
 
-        if self._objective is None:
-            self.build()
         return self._objective
 
-    @property
-    def H(self):
-        """ Return the Hamiltonian as parts C, J """
-
-        if self._C is None:
-            self.build()
-        return self._C, self._J
-    
 class WeightedMaxKCutModel(MaxKCutModel):
 
     def __init__(self, G: nx.Graph, k: int, weight_label : str = "weight"):
-        super().__init__(G, k)
+        super(WeightedMaxCutModel).__init__(G, k)
 
         self.weight_label = weight_label
     
     def _build_objective(self):
         
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
         # construct the quadratic portion of the objective
@@ -174,7 +132,7 @@ class WeightedMaxKCutModel(MaxKCutModel):
                 idx1 = ibase + incr1
                 idx2 = jbase + incr2
                 objective[idx1, idx2] += G[u][v][self.weight_label]
-        self._objective = (np.zeros((n, 1)), objective)
+        return (np.zeros((n, 1)), objective)
 
     def getCutSize(self, partition):
         cut_size = 0

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models/solvers/qciclient.py

@@ -68,10 +68,19 @@ class QciClientMixin:
             client = QciClient(url=self.url, api_token=self.api_token)
         return client
 
+    def getMetrics(self, job_id : str) -> Dict:
+        """
+        Returns a dictionary containing the job metrics.
+
+        """
+        client = self.client
+        metrics = client.get_job_metrics(job_id=job_id)
+        return metrics
+
 class Dirac1Mixin:
     sampler_type = "dirac-1"
     requires_operator = "qubo"
-    max_upper_bound = 1
+    max_upper_bound = 205 # log encoding beyond this level has inherent issues
     job_params_names = ["num_samples", "alpha", "atol"]
 
 class QuboSolverMixin:
@@ -141,7 +150,7 @@ class Dirac3Mixin:
         poly_indices = polynomial.indices
         data = []
         # must find these attributes of the polynomial before uploading
-        max_degree = 0
+        max_degree = 2
         min_degree = len(poly_indices[-1])
         num_variables = 0
         for i in range(len(poly_coeffs)):

{eqc_models-0.10.0 → eqc_models-0.10.2/eqc_models.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: eqc-models
-Version: 0.10.0
+Version: 0.10.2
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com

{eqc_models-0.10.0 → eqc_models-0.10.2}/eqc_models.egg-info/SOURCES.txt

@@ -48,7 +48,9 @@ eqc_models/base/polyeval.c
 eqc_models/base/polyeval.pyx
 eqc_models/base/polynomial.py
 eqc_models/base/quadratic.py
+eqc_models/combinatorics/__init__.py
 eqc_models/combinatorics/setcover.py
+eqc_models/combinatorics/setpartition.py
 eqc_models/graph/__init__.py
 eqc_models/graph/base.py
 eqc_models/graph/hypergraph.py

eqc_models-0.10.0/eqc_models/graph/__init__.py

@@ -1,5 +0,0 @@
-# (C) Quantum Computing Inc., 2024.
-
-from .maxcut import MaxCutModel
-
-__all__ = ["MaxCutModel"]