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

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

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

{eqc_models-0.10.3 → eqc_models-0.11.1}/docs/source/conf.py

@@ -9,7 +9,7 @@
 
 project = 'eqc-models'
 # sphinx adds a period after copyright
-copyright = '2024 Quantum Computing Inc. All rights reserved'
+copyright = '2025 Quantum Computing Inc. All rights reserved'
 author = 'Quantum Computing Inc.'
 
 import importlib.metadata as metadata

eqc_models-0.11.1/eqc_models/assignment/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .qap import QAPModel
+from .resource import ResourceAssignmentModel
+
+__all__ = ["QAPModel", "ResourceAssignmentModel"]

eqc_models-0.11.1/eqc_models/assignment/resource.py

@@ -0,0 +1,165 @@
+from typing import (Dict, List)
+import numpy as np
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
+from eqc_models.base.constraints import InequalitiesMixin
+
+class ResourceAssignmentModel(InequalitiesMixin, ConstrainedQuadraticModel):
+    """
+    Resource assignment model
+
+    Parameters
+    ------------
+
+    resources : List
+    tasks : List
+
+    >>> # name is not a required attribute of the resources or tasks
+    >>> crews = [{"name": "Maintenance Crew 1", "skills": ["A", "F"], "capacity": 5, "cost": 4},
+    ...          {"name": "Baggage Crew 1", "skills": ["B"], "capacity": 4, "cost": 1},
+    ...          {"name": "Maintenance Crew 2", "skills": ["A", "F"], "capacity": 5, "cost": 2}]
+    >>> tasks = [{"name": "Refuel", "skill_need": "F", "load": 3},
+    ...          {"name": "Baggage", "skill_need": "B", "load": 1}]
+    >>> model = ResourceAssignmentModel(crews, tasks)
+    >>> assignments = model.createAssignmentVars()
+    >>> assignments
+    [{'resource': 0, 'task': 0}, {'resource': 1, 'task': 1}, {'resource': 2, 'task': 0}]
+    >>> A, b, senses = model.constrainAssignments(assignments)
+    >>> A
+    array([[3., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 3.],
+           [3., 0., 3.],
+           [0., 3., 0.]], dtype=float32)
+    >>> b
+    array([5., 4., 5., 3., 3.], dtype=float32)
+    >>> senses
+    ['LE', 'LE', 'LE', 'EQ', 'EQ']
+    >>> A, b = model.constraints
+    >>> A
+    array([[3., 0., 0., 1., 0., 0.],
+           [0., 1., 0., 0., 1., 0.],
+           [0., 0., 3., 0., 0., 1.],
+           [3., 0., 3., 0., 0., 0.],
+           [0., 3., 0., 0., 0., 0.]])
+
+    """
+
+    def __init__(self, resources, tasks):
+        self.resources = resources
+        self.checkTasks(tasks)
+        self.tasks = tasks
+        self.assignments = assignments = self.createAssignmentVars()
+        n = len(assignments) + len(resources)
+        self.variables = [f"a{i}" for i in range(len(assignments))]
+        self.upper_bound = np.ones((n,))
+        self.upper_bound[-len(resources):] = [resource["capacity"] for resource in resources]
+        A, b, senses = self.constrainAssignments(assignments)
+        J = np.zeros((n, n))
+        C = np.zeros((n,), dtype=np.float32)
+        # objective is to minimize cost of assignments
+        for j, assignment in enumerate(assignments):
+            C[j] = resources[assignment["resource"]]["cost"] * tasks[assignment["task"]]["load"]
+        super(ResourceAssignmentModel, self).__init__(C, J, A, b)
+        self.senses = senses
+        # always use a machine slack
+        self.machine_slacks = 1
+
+    @classmethod
+    def checkTasks(cls, tasks):
+        for task in tasks:
+            if "skill_need" not in task:
+                raise ValueError("All tasks must have the skill_need attribute")
+            if "load" not in task:
+                raise ValueError("All tasks must have the load attribute")
+            
+    def createAssignmentVars(self):
+        """ Examine all combinatins of possible crew-task assignments """
+
+        assign_vars = []
+        resources = self.resources
+        tasks = self.tasks
+        for i, resource in enumerate(resources):
+            skills = resource["skills"]
+            for j, task in enumerate(tasks):
+                if task["skill_need"] in skills:
+                    assign_vars.append({"resource": i, "task": j})
+        return assign_vars
+
+    def constrainAssignments(self, assignments : List) -> List:
+        """ 
+        Examine the assignments to determine the necessary constraints to 
+        ensure feasibility of solution.
+
+        """
+        # A is sized using the number of crews and the number of assignment variables plus slacks
+        m1 = len(self.resources)
+        m2 = len(self.tasks)
+        n1 = len(assignments)
+        m = m1 + m2
+        n = n1
+        A = np.zeros((m, n), dtype=np.float32)
+        b = np.zeros((m,), dtype=np.float32)
+        for i, resource in enumerate(self.resources):
+            b[i] = resource["capacity"]
+            for k, assignment in enumerate(assignments):
+                if assignment["resource"] == i:
+                    A[i, k] = self.tasks[assignment["task"]]["load"]
+        assignment_coeff = np.max(A)
+        for i, task in enumerate(self.tasks):
+            b[m1+i] = assignment_coeff
+            for k, assignment in enumerate(assignments):
+                if assignment["task"] == i:
+                    A[m1+i, k] = assignment_coeff
+        senses = ["LE" for resource in self.resources] + ["EQ" for task in self.tasks]
+        return A, b, senses
+
+    @property
+    def sum_constraint(self) -> int:
+        """ This value is a suggestion which should be used with a machine slack """
+
+        sc = 0
+        sc += sum([resource["capacity"] for resource in self.resources])
+        sc += len(self.tasks)
+        return sc
+
+    def decode(self, solution : np.array) -> List[Dict]:
+        """ 
+        Convert the binary solution into a list of tasks 
+
+        """
+
+        # ensure solution is array
+        solution = np.array(solution)
+        resource_assignments = [[] for resource in self.resources]
+        vals = [val for val in set(solution) if val <= 1.0]
+        # check if there are fractional values less than 1
+        if solution[~np.logical_or(solution==0, solution>=1)].size>0:
+            # iterate over the values and assign tasks by largest value for tasks 
+            # not assigned already            
+            remaining_tasks = list(range(len(self.tasks)))
+            fltr = self.upper_bound==1
+            while len(remaining_tasks) > 0 and solution[fltr].shape[0]>0:
+               largest = np.max(solution[fltr])
+               indices, = np.where(np.logical_and(fltr, solution == largest))
+               for idx in indices:
+                   assignment = self.assignments[idx]
+                   if assignment["task"] in remaining_tasks:
+                       task = self.tasks[assignment["task"]]
+                       resource_assignments[assignment["resource"]].append(task)
+                       del remaining_tasks[remaining_tasks.index(assignment["task"])]
+                       break
+               fltr = np.logical_and(fltr, solution < largest)
+        else:
+            # Use the restriction that a task cannot be assigned more than once
+            for j, task in enumerate(self.tasks):
+                highest = 0
+                best_resource = None
+                for a, assignment in zip(solution, self.assignments):
+                    if assignment["task"] == j:
+                        if a > highest:
+                            highest = a
+                            best_resource = assignment["resource"]
+                assert best_resource is not None, f"solution had no positive assignment values for {task}"
+                resource_assignments[best_resource].append(task)
+
+        return resource_assignments

{eqc_models-0.10.3 → eqc_models-0.11.1}/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.1/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.10.3 → eqc_models-0.11.1}/eqc_models/ml/classifierqsvm.py

@@ -8,28 +8,204 @@ import json
 import warnings
 from functools import wraps
 import numpy as np
+from sklearn.preprocessing import MinMaxScaler
 
 from eqc_models.ml.classifierbase import ClassifierBase
 
 
 class QSVMClassifier(ClassifierBase):
     """An implementation of QSVM classifier that uses QCi's Dirac-3.
-    
+
+    Parameters
+    ----------
+
+    relaxation_schedule: Relaxation schedule used by Dirac-3; default:
+    2.
+
+    num_samples: Number of samples used by Dirac-3; default: 1.
+
+    lambda_coef: The penalty multipler
+
+    Examples
+    -----------
+
+    >>> from sklearn import datasets
+    >>> from sklearn.preprocessing import MinMaxScaler
+    >>> from sklearn.model_selection import train_test_split
+    >>> iris = datasets.load_iris()
+    >>> X = iris.data
+    >>> y = iris.target
+    >>> scaler = MinMaxScaler()
+    >>> X = scaler.fit_transform(X)
+    >>> for i in range(len(y)):
+    ...     if y[i] == 0:
+    ...         y[i] = -1
+    ...     elif y[i] == 2:
+    ...         y[i] = 1
+    >>> X_train, X_test, y_train, y_test = train_test_split(
+    ...     X,
+    ...     y,
+    ...     test_size=0.2,
+    ...     random_state=42,
+    ... )
+    >>> from eqc_models.ml.classifierqsvm import QSVMClassifier
+    >>> obj = QSVMClassifier(
+    ...     relaxation_schedule=2,
+    ...     num_samples=1,
+    ... )
+    >>> from contextlib import redirect_stdout
+    >>> import io
+    >>> f = io.StringIO()
+    >>> with redirect_stdout(f):
+    ...    obj = obj.fit(X_train, y_train)
+    ...    y_train_prd = obj.predict(X_train)
+    ...    y_test_prd = obj.predict(X_test)
+
+    """
+
+    def __init__(
+        self,
+        relaxation_schedule=1,
+        num_samples=1,
+        lambda_coef=1.0,
+    ):
+        super(QSVMClassifier).__init__()
+
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.lambda_coef = lambda_coef
+        self.fea_scaler = MinMaxScaler(feature_range=(-1, 1))
+
+    def fit(self, X, y):
+        """
+        Build a QSVM classifier from the training set (X, y).
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+        The training input samples.
+
+        y : array-like of shape (n_samples,)
+        The target values.
+
+        Returns
+        -------
+        Response of Dirac-3 in JSON format.
+        """
+
+        assert X.shape[0] == y.shape[0], "Inconsistent sizes!"
+
+        assert set(y) == {-1, 1}, "Target values should be in {-1, 1}"
+
+        X = self.fea_scaler.fit_transform(X)
+        
+        J, C, sum_constraint = self.get_hamiltonian(X, y)
+
+        assert J.shape[0] == J.shape[1], "Inconsistent hamiltonian size!"
+        assert J.shape[0] == C.shape[0], "Inconsistent hamiltonian size!"
+
+        self.set_model(J, C, sum_constraint)
+
+        sol, response = self.solve()
+
+        assert len(sol) == C.shape[0], "Inconsistent solution size!"
+
+        self.params = self.convert_sol_to_params(sol)
+
+        self.X_train = X
+        self.y_train = y
+
+        return response
+
+    def predict_raw(self, X: np.array):
+        """
+        Predict classes for X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+        The predicted classes.
+        """
+        n_records = X.shape[0]
+        X = self.fea_scaler.transform(X)        
+        X_tilde = np.concatenate((X, np.ones((n_records, 1))), axis=1)
+
+        y = np.einsum("i,ki->k", self.params, X_tilde)
+
+        return y
+
+    def predict(self, X: np.array):
+        """
+        Predict classes for X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+        The predicted classes.
+        """
+
+        y = self.predict_raw(X)
+        y = np.sign(y)
+
+        return y
+
+    def get_hamiltonian(
+        self,
+        X: np.array,
+        y: np.array,
+    ):
+        n_records = X.shape[0]
+        n_dims = X.shape[1]
+
+        J = np.zeros(shape=(1 + n_dims, 1 + n_dims), dtype=np.float32)
+        C = np.zeros(shape=(1 + n_dims,), dtype=np.float32)
+
+        X_tilde = np.concatenate((X, np.ones((n_records, 1))), axis=1)
+
+        J = self.lambda_coef * np.einsum(
+            "i,ik,il->kl", y**2, X_tilde, X_tilde
+        )
+
+        for k in range(n_dims):
+            J[k][k] += 0.5
+
+        C = -2.0 * self.lambda_coef * np.einsum("i,ik->k", y, X_tilde)
+
+        J = 0.5 * (J + J.transpose())
+        C = C.reshape((1 + n_dims, 1))
+
+        return J, C, 1.0
+
+    def convert_sol_to_params(self, sol):
+        return np.array(sol)
+
+
+class QSVMClassifierDual(ClassifierBase):
+    """An implementation of dual QSVM classifier that uses QCi's Dirac-3.
+
     Parameters
     ----------
-    
+
     relaxation_schedule: Relaxation schedule used by Dirac-3; default:
     2.
-    
+
     num_samples: Number of samples used by Dirac-3; default: 1.
-    
+
     upper_limit: Coefficient upper limit; a regularization parameter;
     default: 1.0.
-    
+
     gamma: Gaussian kernel parameter; default: 1.0.
-    
+
     eta: A penalty multiplier; default: 1.0.
-    
+
     zeta: A penalty multiplier; default: 1.0.
 
     Examples
@@ -54,8 +230,8 @@ class QSVMClassifier(ClassifierBase):
     ...     test_size=0.2,
     ...     random_state=42,
     ... )
-    >>> from eqc_models.ml.classifierqsvm import QSVMClassifier
-    >>> obj = QSVMClassifier(
+    >>> from eqc_models.ml.classifierqsvm import QSVMClassifierDual
+    >>> obj = QSVMClassifierDual(
     ...     relaxation_schedule=2,
     ...     num_samples=1,
     ...     upper_limit=1.0,
@@ -70,9 +246,9 @@ class QSVMClassifier(ClassifierBase):
     ...    obj = obj.fit(X_train, y_train)
     ...    y_train_prd = obj.predict(X_train)
     ...    y_test_prd = obj.predict(X_test)
-    
+
     """
-    
+
     def __init__(
         self,
         relaxation_schedule=2,
@@ -81,8 +257,8 @@ class QSVMClassifier(ClassifierBase):
         gamma=1.0,
         eta=1.0,
         zeta=1.0,
-    ):        
-        super(QSVMClassifier).__init__()
+    ):
+        super(QSVMClassifierDual).__init__()
 
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
@@ -97,20 +273,20 @@ class QSVMClassifier(ClassifierBase):
     def fit(self, X, y):
         """
         Build a QSVM classifier from the training set (X, y).
-    
+
         Parameters
         ----------
         X : {array-like, sparse matrix} of shape (n_samples, n_features)
-        The training input samples. 
-    
+        The training input samples.
+
         y : array-like of shape (n_samples,)
         The target values.
-    
+
         Returns
         -------
         Response of Dirac-3 in JSON format.
         """
-                
+
         assert X.shape[0] == y.shape[0], "Inconsistent sizes!"
 
         assert set(y) == {-1, 1}, "Target values should be in {-1, 1}"
@@ -144,17 +320,17 @@ class QSVMClassifier(ClassifierBase):
     def predict(self, X: np.array):
         """
         Predict classes for X.
-        
+
         Parameters
         ----------
         X : {array-like, sparse matrix} of shape (n_samples, n_features)
-    
+
         Returns
         -------
         y : ndarray of shape (n_samples,)
         The predicted classes.
         """
-                
+
         assert self.X_train is not None, "Model not trained yet!"
         assert self.y_train is not None, "Model not trained yet!"