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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.10.2
+Version: 0.11.0
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com
@@ -22,6 +22,7 @@ Provides-Extra: dev
 Requires-Dist: pytest<8,>=7.1.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: sphinx_rtd_theme<2,>=1.3.0; extra == "dev"
+Dynamic: license-file
 
 # EQC Models
 

{eqc_models-0.10.2 → eqc_models-0.11.0}/eqc_models/base/__init__.py

@@ -65,8 +65,10 @@ from .quadratic import (ConstrainedQuadraticModel, QuadraticModel)
 from .polynomial import (PolynomialModel, ConstrainedPolynomialModel)
 from .base import (ModelSolver, EqcModel)
 from .operators import (QUBO, Polynomial)
+from .results import SolutionResults
 
 __all__ = ["ConstraintsMixIn", "ConstraintModel", "ConstrainedQuadraticModel", 
            "QuadraticModel", "PolynomialModel", "ConstrainedPolynomialModel",
            "InequalitiesMixin", "InequalityConstraintModel",
-           "EqcModel", "ModelSolver", "QUBO", "Polynomial"]
+           "EqcModel", "ModelSolver", "QUBO", "Polynomial",
+           "SolutionResults"]

eqc_models-0.11.0/eqc_models/base/results.py

@@ -0,0 +1,94 @@
+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.
+
+    """
+
+    solutions : np.ndarray
+    energies : np.ndarray
+    counts : np.array
+    objectives : np.ndarray
+    run_time : np.ndarray
+    preprocessing_time : np.ndarray
+    postprocessing_time : np.ndarray
+    penalties : np.ndarray = None
+    device : str = None
+    time_units : str = "ns"
+
+    @property
+    def device_time(self):
+        pre = self.preprocessing_time
+        runtime = np.sum(self.run_time)
+        post = np.sum(self.postprocessing_time)
+        return pre + runtime + post
+
+    @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"])
+        energies = np.array(response["results"]["energies"])
+        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.evaluatePenalty(solution[i]) + model.offset
+        else:
+            penalties = None
+        counts = np.array(response["results"]["counts"])
+# 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
+        job_id = response["job_info"]["job_id"]
+        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"]["postprocessing_time"]
+        pre = device["samples"]["preprocessing_time"]
+        results = SolutionResults(solutions, energies, counts, objectives, 
+                                  runtime, pre, post, penalties=penalties,
+                                  device=device_type, time_units="ns")
+
+        return results

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

@@ -41,41 +41,57 @@ class SetCoverModel(ConstrainedQuadraticModel):
     >>> X = [set(['A', 'B']), set(['B', 'C']), set(['C'])]
     >>> weights = [2, 2, 1]
     >>> model = SetCoverModel(X, weights)
-    >>> model.penalty_multiplier = 2
+    >>> model.penalty_multiplier = 8
+    >>> lhs, rhs = model.constraints
+    >>> lhs
+    array([[ 1,  0,  0,  0,  0],
+           [ 1,  1,  0, -1,  0],
+           [ 0,  1,  1,  0, -1]])
     >>> from eqc_models.solvers import Dirac3IntegerCloudSolver
     >>> solver = Dirac3IntegerCloudSolver()
     >>> response = solver.solve(model, relaxation_schedule=1, num_samples=5) #doctest: +ELLIPSIS
     20...
     >>> solutions = response["results"]["solutions"]
     >>> solutions[0]
-    [1, 0, 1, 0, 0, 0]
-    >>> model.decode(solutions[0])
-    [{'B', 'A'}, {'C'}]
+    [1, 0, 1, 0, 0]
+    >>> selections = model.decode(solutions[0])
+    >>> assert {'B', 'A'} in selections
+    >>> assert {'C'} in selections
+    >>> assert len(selections) == 2
 
     """
 
     def __init__(self, subsets, weights):
         # ensure that X is ordered
-        self.X = X = list(subsets)
-        self.S = S = set()
+        self.S = S = list(subsets)
+        self.universal_set = U = set()
 
         for x in subsets:
-            S = S.union(x)
+            U.update(x)
         # elements is sorted to maintain consistent output
-        elements = [a for a in S]
+        elements = [a for a in U]
         elements.sort()
         # constraints 
         A = []
         b = []
-        variables = [f'x_{i}' for i in range(len(X))]
+        variables = [f'x_{i}' for i in range(len(S))]
         pos = 0
+        num_slacks = 0
+        slack_ub = []
         for a in elements:
-            variables.append(f"s_{pos}")
-            constraint = [1 if a in X[i] else 0 for i in range(len(X))]
-            slacks = [0 for i in range(len(S))]
-            slacks[pos] = -1
+            num_sets = sum([1 if a in S[i] else 0 for i in range(len(S))])
+            assert num_sets >= 1, "Invalid subsets, check the universal set"
+            if num_sets > 1:
+                num_slacks += 1
+            slack_ub.append(num_sets-1)
+        for i, a in enumerate(elements):
+            constraint = [1 if a in S[j] else 0 for j in range(len(S))]
+            slacks = [0 for i in range(num_slacks)]
+            if slack_ub[i] > 0:
+                variables.append(f"s_{pos}")
+                slacks[pos] = -1
+                pos += 1
             A.append(constraint + slacks)
-            pos += 1
             b.append(1)
         n = len(variables)
         J = np.zeros((n, n))
@@ -84,11 +100,12 @@ class SetCoverModel(ConstrainedQuadraticModel):
         # call the superclass constructor with the objective and constraints
         super(SetCoverModel, self).__init__(h, J, np.array(A), np.array(b))
         # set upper bound on the variables to be 1 for x_i and the length of X minus 1 for the slacks
-        self.upper_bound = np.array([1 for i in range(len(weights))] + [len(X)-1 for i in range(n-len(weights))])
+        slack_ub = [val for val in slack_ub if val > 0]
+        self.upper_bound = np.array([1 for i in range(len(weights))] + slack_ub)
 
     def decode(self, solution) -> List:
         xbar = []
-        for i in range(len(self.X)):
+        for i in range(len(self.S)):
             if solution[i] > 0.5:
-                xbar.append(self.X[i])
+                xbar.append(self.S[i])
         return xbar

eqc_models-0.11.0/eqc_models/sequence/scheduling.py

@@ -0,0 +1,29 @@
+import numpy as np
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
+from eqc_models.base.constraints import InequalitiesMixin
+
+class CrewSchedulingModel(ConstrainedQuadraticModel):
+    """
+    Crew scheduling model
+
+    Parameters
+    ------------
+
+    crews : List
+    tasks : List
+
+    >>> crews = [{"name": "Maintenance Crew 1", "skills": ["A", "F"]}, 
+    ...          {"name": "Baggage Crew 1", "skills": ["B"]},
+    ...          {"name": "Maintenance Crew 2", "skills": ["A", "F"]}]
+    >>> tasks = [{"name": "Refuel", "skill_need": "F"},
+    ...          {"name": "Baggage", "skill_need": "B"}]
+
+    """
+
+    def __init__(self, crews, tasks):
+        self.crews = crews
+        self.tasks = tasks
+
+    def decode(self, solution) -> np.ndarray:
+        """ Translate the solution into a list of tasks for each crew """
+

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.10.2
+Version: 0.11.0
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com
@@ -22,6 +22,7 @@ Provides-Extra: dev
 Requires-Dist: pytest<8,>=7.1.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: sphinx_rtd_theme<2,>=1.3.0; extra == "dev"
+Dynamic: license-file
 
 # EQC Models
 

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

@@ -48,6 +48,7 @@ eqc_models/base/polyeval.c
 eqc_models/base/polyeval.pyx
 eqc_models/base/polynomial.py
 eqc_models/base/quadratic.py
+eqc_models/base/results.py
 eqc_models/combinatorics/__init__.py
 eqc_models/combinatorics/setcover.py
 eqc_models/combinatorics/setpartition.py
@@ -73,6 +74,7 @@ eqc_models/ml/regressor.py
 eqc_models/ml/regressorbase.py
 eqc_models/ml/reservoir.py
 eqc_models/sequence/__init__.py
+eqc_models/sequence/scheduling.py
 eqc_models/sequence/tsp.py
 eqc_models/solvers/__init__.py
 eqc_models/solvers/qciclient.py
@@ -101,6 +103,7 @@ scripts/qplib_reader.py
 scripts/qplib_runner.py
 scripts/qsvm_iris_dirac3.py
 scripts/reservoir_forecast.py
+scripts/results_example.py
 scripts/rundoctests.py
 scripts/utils.py
 test/doctest_base.py

eqc_models-0.11.0/scripts/results_example.py

@@ -0,0 +1,31 @@
+from eqc_models.solvers import Dirac3ContinuousCloudSolver
+from eqc_models.base import PolynomialModel
+from eqc_models.base import SolutionResults
+
+def solve_polynomial(polynomial_coefficients, polynomial_indices, upper_bound, solver, **kwargs):
+
+    model = PolynomialModel(polynomial_coefficients, polynomial_indices)
+    model.upper_bound = ub
+
+    response = solver.solve(model, **kwargs)
+
+    results = SolutionResults.from_cloud_response(model, response, solver)
+
+    return results
+
+if __name__ == "__main__":
+    import os.path
+    import json
+    import numpy as np
+
+    coefficients = np.array([-1, -1, 1])
+    indices = np.array([[1, 1], [2, 2], [1, 2]])
+    ub = [1, 1]
+    solver = Dirac3ContinuousCloudSolver()
+    results = solve_polynomial(coefficients, indices, ub, solver, num_samples=2, relaxation_schedule=1, sum_constraint=1)
+
+    print("Job results:")
+    print("Solution energies:", results.energies)
+    print("Solutions:", results.solutions)
+    print("Total device time:", results.device_time)
+    print("Average device time:", results.device_time / results.total_samples)

{eqc_models-0.10.2 → eqc_models-0.11.0}/test/testsetcovermodel.py

@@ -15,11 +15,11 @@ class SetCoverTestCase(TestCase):
 
     def testConstraints(self):
         lhs, rhs = self.model.constraints
-        assert lhs.shape == (3, 6)
+        assert lhs.shape == (3, 5)
         assert rhs.shape == (3,)
-        assert (lhs == [[1, 0, 0, -1, 0, 0],[1, 1, 0, 0, -1, 0],[0, 1, 1, 0, 0, -1]]).all()
+        assert (lhs == [[1, 0, 0, 0, 0],[1, 1, 0, -1, 0],[0, 1, 1, 0, -1]]).all()
         assert (rhs == [1, 1, 1]).all()
 
     def testObjective(self):
         objective = self.model.linear_objective
-        assert (objective == [2, 2, 1, 0, 0, 0]).all()
+        assert (objective == [2, 2, 1, 0, 0]).all()