eqc-models 0.9.8__py3-none-any.whl

eqc_models-0.9.8.data/platlib/eqc_models/ml/decomposition.py

@@ -0,0 +1,363 @@
+# (C) Quantum Computing Inc., 2024.
+# Import libs
+import os
+import sys
+import time
+import datetime
+import json
+import warnings
+from functools import wraps
+import numpy as np
+
+from qci_client import QciClient
+
+from eqc_models import QuadraticModel
+from eqc_models.solvers.qciclient import (
+    Dirac3CloudSolver,
+    Dirac3ContinuousCloudSolver,
+    Dirac1CloudSolver,
+)
+
+
+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,
+        num_samples=1,
+    ):
+        super(self).__init__(None, None, None)
+
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+
+    def _get_hamiltonian(
+        self,
+        X: np.array,
+    ):
+        pass
+
+    def _set_model(self, J, C, sum_constraint):
+        # Set hamiltonians
+        self._C = C
+        self._J = J
+        self._H = C, J
+        self._sum_constraint = sum_constraint
+
+        # Set upper_bound
+        num_variables = C.shape[0]
+        self.upper_bound = sum_constraint * np.ones((num_variables,))
+
+        return
+
+    def _solve(self):
+        solver = Dirac3ContinuousCloudSolver()
+        response = solver.solve(
+            self,
+            relaxation_schedule=self.relaxation_schedule,
+            solution_precision=1,
+            sum_constraint=self._sum_constraint,
+            num_samples=self.num_samples,
+        )
+
+        sol = response["results"]["solutions"][0]
+
+        return sol, response
+
+    def _solve_d1_test(self):
+        qubo = self._J
+
+        # Make sure matrix is symmetric to machine precision
+        qubo = 0.5 * (qubo + qubo.transpose())
+
+        # Instantiate
+        qci = QciClient()
+
+        # Create json objects
+        qubo_json = {
+            "file_name": "qubo_tutorial.json",
+            "file_config": {
+                "qubo": {"data": qubo, "num_variables": qubo.shape[0]},
+            },
+        }
+
+        response_json = qci.upload_file(file=qubo_json)
+        qubo_file_id = response_json["file_id"]
+
+        # Setup job json
+        job_params = {
+            "device_type": "dirac-1",
+            "alpha": 1.0,
+            "num_samples": 20,
+        }
+        job_json = qci.build_job_body(
+            job_type="sample-qubo",
+            job_params=job_params,
+            qubo_file_id=qubo_file_id,
+            job_name="tutorial_eqc1",
+            job_tags=["tutorial_eqc1"],
+        )
+        print(job_json)
+
+        # Run the job
+        job_response_json = qci.process_job(
+            job_body=job_json,
+        )
+
+        print(job_response_json)
+
+        results = job_response_json["results"]
+        energies = results["energies"]
+        samples = results["solutions"]
+
+        if True:
+            print("Energies:", energies)
+
+        sol = np.array(samples[0])
+
+        print(sol)
+
+        return sol
+
+    def fit(self, X):
+        pass
+
+    def transform(self, X: np.array):
+        pass
+
+    def fit_transform(self, X):
+        pass
+
+    def get_dynamic_range(self):
+        C = self._C
+        J = self._J
+
+        if C is None:
+            return
+
+        if J is None:
+            return
+
+        absc = np.abs(C)
+        absj = np.abs(J)
+        minc = np.min(absc[absc > 0])
+        maxc = np.max(absc)
+        minj = np.min(absj[absj > 0])
+        maxj = np.max(absj)
+
+        minval = min(minc, minj)
+        maxval = max(maxc, maxj)
+
+        return 10 * np.log10(maxval / minval)
+
+
+class PCA(DecompBase):
+    """
+    An implementation of Principal component analysis (PCA) that
+    uses QCi's Dirac-3.
+
+    Linear dimensionality reduction using Singular Value
+    Decomposition of the data to project it to a lower dimensional
+    space.
+
+    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.
+
+    Examples
+    -----------
+    
+    >>> from sklearn import datasets
+    >>> iris = datasets.load_iris()
+    >>> X = iris.data
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> scaler = StandardScaler()
+    >>> X = scaler.fit_transform(X)
+    >>> from eqc_models.ml.decomposition import PCA
+    >>> from contextlib import redirect_stdout
+    >>> import io
+    >>> f = io.StringIO()
+    >>> with redirect_stdout(f):
+    ...    obj = PCA(
+    ...        n_components=4,
+    ...        relaxation_schedule=2,
+    ...        num_samples=1,
+    ...    )
+    ...    X_pca = obj.fit_transform(X)
+    
+    """
+    
+    def __init__(
+        self,
+        n_components=None,
+        relaxation_schedule=2,
+        num_samples=1,
+    ):
+        self.n_components = n_components
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.X = None
+        self.X_pca = None
+
+    def _get_hamiltonian(
+        self,
+        X: np.array,
+    ):
+        num_records = X.shape[0]
+        num_features = X.shape[1]
+
+        J = -np.matmul(X.transpose(), X)
+
+        assert J.shape[0] == num_features
+        assert J.shape[1] == num_features
+
+        C = np.zeros((num_features, 1))
+
+        return J, C
+
+    def _get_first_component(self, X):
+        J, C = self._get_hamiltonian(X)
+
+        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, 1.0)
+
+        sol, response = self._solve()
+
+        assert len(sol) == C.shape[0], "Inconsistent solution size!"
+
+        fct = np.linalg.norm(sol)
+        if fct > 0:
+            fct = 1.0 / fct
+
+        v0 = fct * np.array(sol)
+        v0 = v0.reshape((v0.shape[0], 1))
+
+        lambda0 = np.matmul(np.matmul(v0.transpose(), -J), v0)[0][0]
+
+        assert lambda0 >= 0, "Unexpected negative eigenvalue!"
+
+        fct = np.sqrt(lambda0)
+        if fct > 0:
+            fct = 1.0 / fct
+
+        u0 = fct * np.matmul(X, v0)
+        u0 = u0.reshape(-1)
+
+        fct = np.linalg.norm(u0)
+        if fct > 0:
+            fct = 1.0 / fct
+
+        u0 = fct * u0
+
+        return u0, response
+
+    def fit(self, X):
+        """
+        Build a PCA object from the training set X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+        The training input samples.
+
+        Returns
+        -------
+        responses. 
+        A dirct containing Dirac responses.
+        """
+
+        num_features = X.shape[1]
+        if self.n_components is None:
+            n_components = num_features
+        else:
+            n_components = self.n_components
+
+        n_components = min(n_components, num_features)
+
+        self.X = X.copy()
+        self.X_pca = []
+        resp_hash = {}
+        for i in range(n_components):
+            u, resp = self._get_first_component(X)
+            self.X_pca.append(u)
+            u = u.reshape((u.shape[0], 1))
+
+            X = X - np.matmul(
+                u,
+                np.matmul(u.transpose(), X),
+            )
+
+            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]
+        assert self.X_pca.shape[1] == n_components
+
+        return resp_hash
+
+    def transform(self, X: np.array):
+        """
+        Apply dimensionality reduction to X.
+
+        X is projected on the first principal components previously extracted
+        from a training set.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+        New data, where `n_samples` is the number of samples
+        and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : array-like of shape (n_samples, n_components)
+        Projection of X in the first principal components, where `n_samples`
+        is the number of samples and `n_components` is the number of the components.
+        """
+        if self.X is None:
+            return
+
+        return self.X_pca
+
+    def fit_transform(self, X):
+        """
+        Fit the model with X and apply the dimensionality reduction on X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+        Training data, where `n_samples` is the number of samples
+        and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+        Transformed values.
+        """
+
+        self.fit(X)
+
+        return self.transform(X)

eqc_models-0.9.8.data/platlib/eqc_models/ml/forecast.py

@@ -0,0 +1,255 @@
+import sys
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LinearRegression, Ridge
+
+from .reservoir import QciReservoir
+from .forecastbase import BaseForecastModel
+
+class ReservoirForecastModel(BaseForecastModel, QciReservoir):
+    """
+    A reservoir based forecast model.
+
+    Parameters
+    ----------
+
+    ip_addr: The IP address of the device.
+
+    num_nodes: Number of reservoir network nodes.
+
+    feature_scaling: The factor used to scale the reservoir output.
+
+    num_pads: Size of the pad used in the reservoir input;
+    default: 0.
+
+    reg_coef: L2 regularization coefficient for linear regression;
+    default: 0.
+        
+    device: The QCi reservoir device. Currently only 'EmuCore' is
+    supported; default: EmuCore.
+
+
+    Examples
+    ---------
+    
+    >>> MAX_TRAIN_DAY = 800
+    >>> IP_ADDR = "172.22.19.49"
+    >>> FEATURE_SCALING = 0.1
+    >>> NUM_NODES = 1000
+    >>> NUM_PADS = 100
+    >>> LAGS = 2
+    >>> from contextlib import redirect_stdout
+    >>> import io
+    >>> f = io.StringIO()
+    >>> from eqc_models.ml import ReservoirForecastModel
+    >>> with redirect_stdout(f):
+    ...    model = ReservoirForecastModel(
+    ...        ip_addr=IP_ADDR,
+    ...        num_nodes=NUM_NODES,
+    ...        feature_scaling=FEATURE_SCALING,
+    ...        num_pads=NUM_PADS,
+    ...        device="EmuCore",
+    ...    )
+    ...    model.fit(
+    ...        data=train_df,
+    ...        feature_fields=["norm_cell_prod"],
+    ...        target_fields=["norm_cell_prod"],
+    ...        lags=LAGS,
+    ...        horizon_size=1,
+    ...    )
+    ...    y_train_pred = model.predict(train_df, mode="in_sample")
+    ...    y_test_pred = model.predict(test_df, mode="in_sample")
+    >>> model.close()
+    
+    """
+    
+    def __init__(
+        self,
+        ip_addr,
+        num_nodes,
+        feature_scaling,
+        num_pads: int = 0,
+        reg_coef: float = 0.0,
+        device: str = "EmuCore",
+    ):
+        super(ReservoirForecastModel).__init__()
+        BaseForecastModel.__init__(self)
+        QciReservoir.__init__(self, ip_addr, num_nodes)
+        
+        assert device == "EmuCore", "Unknown device!"
+
+        self.ip_addr = ip_addr
+        self.num_nodes = num_nodes
+        self.feature_scaling = feature_scaling
+        self.num_pads = num_pads
+        self.reg_coef = reg_coef        
+        self.device = device
+
+        self.lock_id = None
+        self.lin_model = None
+        self.feature_fields = None
+        self.target_fields = None
+        self.lags = None
+        self.horizon_size = None
+        self.zero_pad_data = None
+        self.train_pad_data = None        
+        
+        self.init_reservoir()
+
+    def close(self):
+        self.release_lock()
+
+    def fit(
+        self,
+        data: pd.DataFrame,
+        feature_fields: list,
+        target_fields: list,
+        lags: int = 0,
+        horizon_size: int = 1,
+    ):
+        """A function to train a forecast model.
+
+        Parameters
+        ----------
+
+        data: A pandas data frame that contain the time series.
+
+        feature_fields: A list of fields in the data frame that are as
+        inputs to the reservoir.
+
+        target_fields: A list of fields in teh data frame that are to be
+        forecasted.
+
+        lags: Number of lags used; default = 0.
+
+        horizon_size: Size of the horizon, e.g. number of forecast
+        steps.
+
+        """
+
+        # Pad input
+        num_pads = self.num_pads
+        if num_pads is not None and num_pads > 0:
+            self.zero_pad_data = pd.DataFrame()
+            for item in data.columns:
+                self.zero_pad_data[item] = np.zeros(shape=(num_pads))
+                
+            data = pd.concat([self.zero_pad_data, data])
+        
+        # Prep data
+        fea_data = np.array(data[feature_fields])
+        targ_data = np.array(data[target_fields])
+
+        X_train, y_train, steps = self.prep_fea_targs(
+            fea_data=fea_data,
+            targ_data=targ_data,
+            window_size=lags + 1,
+            horizon_size=horizon_size,
+        )
+
+        # Save some parameters
+        self.feature_fields = feature_fields
+        self.target_fields = target_fields
+        self.lags = lags
+        self.horizon_size = horizon_size
+
+        # Push to reservoir        
+        X_train_resp = self.push_reservoir(X_train)
+
+        if num_pads is not None and num_pads > 0:
+            X_train_resp = X_train_resp[num_pads:]
+            y_train = y_train[num_pads:]
+            
+        # Build linear model
+        #self.lin_model = LinearRegression(fit_intercept=True)
+        self.lin_model = Ridge(alpha=self.reg_coef, fit_intercept=True)
+        self.lin_model.fit(X_train_resp, y_train)
+
+        # Get predictions
+        y_train_pred = self.lin_model.predict(X_train_resp)
+
+        # Echo some stats
+        train_stats = self.get_stats(y_train, y_train_pred)
+
+        print("Training stats:", train_stats)
+
+        if num_pads is not None and num_pads > 0:        
+            self.train_pad_data = data.tail(num_pads)
+
+        return
+
+    def predict(
+        self,
+        data: pd.DataFrame,
+        pad_mode: str = "zero",
+        mode: str = "in_sample",
+    ):
+        """A function to get predictions from forecast model.
+
+        Parameters
+        ----------
+
+        data: A pandas data frame that contain the time series.
+
+        pad_mode: Mode of the reservoir input padding, either
+        'last_train' or 'zero'; default: 'zero.
+        
+        mode: A value of 'out_of_sample' predicts the horizon
+        following the time series. A value of 'in_sample' predicts in
+        sample (used for testing); default: in_sample.
+
+        Returns
+        -------
+
+        The predictions: numpy.array((horizon_size, num_dims)).
+
+        """
+
+        assert self.lin_model is not None, "Model not train yet!"
+        assert mode in ["in_sample", "out_of_sample"], (
+            "Unknown mode <%s>!" % mode
+        )
+
+        num_pads = self.num_pads
+        if num_pads is not None and num_pads > 0:
+            if pad_mode == "last_train":
+                pad_data = self.train_pad_data
+            else:
+                pad_data = self.zero_pad_data
+            
+            data = pd.concat([pad_data, data])
+        
+        num_records = data.shape[0]
+        fea_data = np.array(data[self.feature_fields])
+        targ_data = np.array(data[self.target_fields])
+        
+        if mode == "in_sample":
+            X, y, _ = self.prep_fea_targs(
+                fea_data=fea_data,
+                targ_data=targ_data,
+                window_size=self.lags + 1,
+                horizon_size=self.horizon_size,
+            )
+        elif mode == "out_of_sample":
+            X = self.prep_out_of_sample(
+                fea_data=fea_data,
+                window_size=self.lags + 1,
+                horizon_size=self.horizon_size,
+            )
+        else:
+            assert False, "Unknown mode <%s>!" % mode
+            
+        X_resp = self.push_reservoir(X)
+
+        if self.num_pads is not None and self.num_pads > 0:
+            X_resp = X_resp[self.num_pads:]
+            y = y[self.num_pads:]
+            
+        y_pred = self.lin_model.predict(X_resp)
+
+        # Echo some stats
+        if mode == "in_sample":
+            stats = self.get_stats(y, y_pred)
+            print("In-sample prediction stats:", stats)
+        
+        return y_pred