eqc-models 0.10.3__py3-none-any.whl → 0.11.1__py3-none-any.whl

eqc_models-0.11.1.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.10.3.data → eqc_models-0.11.1.data}/platlib/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!"
 

{eqc_models-0.10.3.data → eqc_models-0.11.1.data}/platlib/eqc_models/ml/decomposition.py

@@ -21,17 +21,17 @@ from eqc_models.solvers.qciclient import (
 
 class DecompBase(QuadraticModel):
     """An Base class for decomposition algorithms.
-    
+
     Parameters
     ----------
-    
+
     relaxation_schedule: Relaxation schedule used by Dirac-3; default:
     2.
-    
+
     num_samples: Number of samples used by Dirac-3; default: 1.
 
     """
-    
+
     def __init__(
         self,
         relaxation_schedule=2,
@@ -163,8 +163,7 @@ class DecompBase(QuadraticModel):
 
 
 class PCA(DecompBase):
-    """
-    An implementation of Principal component analysis (PCA) that
+    """An implementation of Principal component analysis (PCA) that
     uses QCi's Dirac-3.
 
     Linear dimensionality reduction using Singular Value
@@ -173,18 +172,22 @@ class PCA(DecompBase):
 
     Parameters
     ----------
-    
+
     n_components: Number of components to keep; if n_components is not
     set all components are kept; default: None.
-    
+
     relaxation_schedule: Relaxation schedule used by Dirac-3; default:
     2.
-    
+
     num_samples: Number of samples used by Dirac-3; default: 1.
 
+    mode: Compute the largest or smallest principal components,
+    largest_components vs. smallest_components; default:
+    largest_components.
+
     Examples
     -----------
-    
+
     >>> from sklearn import datasets
     >>> iris = datasets.load_iris()
     >>> X = iris.data
@@ -202,18 +205,25 @@ class PCA(DecompBase):
     ...        num_samples=1,
     ...    )
     ...    X_pca = obj.fit_transform(X)
-    
+
     """
-    
+
     def __init__(
         self,
         n_components=None,
         relaxation_schedule=2,
         num_samples=1,
+        mode="largest_components",
     ):
         self.n_components = n_components
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
+
+        assert mode in ["largest_components", "smallest_components"], (
+            "Invalid value of mode <%s>" % mode
+        )
+
+        self.mode = mode
         self.X = None
         self.X_pca = None
 
@@ -224,12 +234,20 @@ class PCA(DecompBase):
         num_records = X.shape[0]
         num_features = X.shape[1]
 
-        J = -np.matmul(X.transpose(), X)
+        J = np.matmul(X.transpose(), X)
 
         assert J.shape[0] == num_features
         assert J.shape[1] == num_features
 
-        C = np.zeros((num_features, 1))
+        C = -np.sum(J, axis=1)
+
+        assert C.shape[0] == num_features
+
+        C = C.reshape((num_features, 1))
+
+        if self.mode == "largest_components":
+            J = -J
+            C = -C
 
         return J, C
 
@@ -239,12 +257,17 @@ class PCA(DecompBase):
         assert J.shape[0] == J.shape[1], "Inconsistent hamiltonian size!"
         assert J.shape[0] == C.shape[0], "Inconsistent hamiltonian size!"
 
+        sum_constraint = 0.5 * (1.0 + C.shape[0])
+        
         self._set_model(J, C, 1.0)
 
         sol, response = self._solve()
 
         assert len(sol) == C.shape[0], "Inconsistent solution size!"
 
+        sol = np.array(sol)
+        sol = 2.0 * sol - 1.0
+        
         fct = np.linalg.norm(sol)
         if fct > 0:
             fct = 1.0 / fct
@@ -282,7 +305,7 @@ class PCA(DecompBase):
 
         Returns
         -------
-        responses. 
+        responses.
         A dirct containing Dirac responses.
         """
 
@@ -310,7 +333,7 @@ class PCA(DecompBase):
             assert X.shape == self.X.shape, "Inconsistent size!"
 
             resp_hash["component_%d_response" % (i + 1)] = resp
-            
+
         self.X_pca = np.array(self.X_pca).transpose()
 
         assert self.X_pca.shape[0] == self.X.shape[0]

eqc_models-0.11.1.data/platlib/eqc_models/process/base.py

@@ -0,0 +1,13 @@
+import networkx as nx
+from eqc_models.base import ConstrainedPolynomialModel
+
+class ProcessModel:
+    def __init__(self, G : nx.DiGraph):
+        self.G = G
+
+    @staticmethod
+    def process_constraints(G : nx.DiGraph):
+        """ Build process constraints from the graph """
+
+    def constraints(self) -> Tuple[np.ndarray]:
+        """ """

eqc_models-0.11.1.data/platlib/eqc_models/process/mpc.py

@@ -0,0 +1,17 @@
+from eqc_models.process.base import ProcessModel
+
+class ModelPredictiveControl(ProcessModel):
+    """ Base class for implementing MPC optimization problems """
+
+    def __init__(self, G : nx.Graph, V : int=1, V_T:float=0.0):
+        self.processArgs(*args, **kwargs)
+        self.T = T
+        self.V_T = V_T
+        super(ModelPredictiveControl, self).__init__(G)
+        
+    def processArgs(self, *args, **kwargs):
+        """ Provide a method to capture arguments necessary for configuring an instance """
+        raise NotImplementedError("subclass must implement processArgs")
+
+    def constraints(self) -> Tuple[np.ndarray]:
+        

{eqc_models-0.10.3.data → eqc_models-0.11.1.data}/platlib/eqc_models/solvers/qciclient.py

@@ -519,7 +519,8 @@ class Dirac3CloudSolver(Dirac3Mixin, QciClientSolver):
             of photons that are present in a given quantum state.
             Modify this value to control the relaxation schedule more
             precisely than the four presets given in schedules 1
-            through 4. Allowed values are decimals between 0.1 and 2.
+            through 4. Allowed values are decimals between 0.000133333333333 and 
+            0.001.
         quantum_fluctuation_coefficient: int 
             an integer value which Sets the amount of loss introduced
             into the system for each loop during the measurement process.
@@ -622,7 +623,8 @@ class Dirac3IntegerCloudSolver(Dirac3Mixin, QciClientSolver):
             of photons that are present in a given quantum state.
             Modify this value to control the relaxation schedule more
             precisely than the four presets given in schedules 1
-            through 4. Allowed values are decimals between 0.1 and 2.
+            through 4. Allowed values are decimals between 0.000133333333333 
+            and 0.001.
         quantum_fluctuation_coefficient: int 
             an integer value which Sets the amount of loss introduced
             into the system for each loop during the measurement process.
@@ -716,7 +718,8 @@ class Dirac3ContinuousCloudSolver(Dirac3Mixin, QciClientSolver):
             of photons that are present in a given quantum state.
             Modify this value to control the relaxation schedule more
             precisely than the four presets given in schedules 1
-            through 4. Allowed values are decimals between 0.1 and 2.
+            through 4. Allowed values are decimals between 0.000133333333333 
+            and 0.001.
         quantum_fluctuation_coefficient: int 
             an integer value which Sets the amount of loss introduced
             into the system for each loop during the measurement process.

{eqc_models-0.10.3.dist-info → eqc_models-0.11.1.dist-info}/METADATA

@@ -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