eqc-models 0.9.8__py3-none-any.whl

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

@@ -0,0 +1,139 @@
+# (C) Quantum Computing Inc., 2024.
+# Import libs
+import numpy as np
+import pandas as pd
+from sklearn.metrics import (
+    mean_squared_error,
+    mean_absolute_percentage_error,
+)
+
+
+# Define a base class for forecast models
+class BaseForecastModel:
+    """
+    A base class for forecast models.
+    """
+    def __init__(self):
+        pass
+
+    def prep_fea_targs(
+        self,
+        fea_data: np.array,
+        targ_data: np.array,
+        window_size: int = 1,
+        horizon_size: int = 1,
+    ):
+        num_records = fea_data.shape[0]
+
+        assert (
+            targ_data.shape[0] == num_records
+        ), "Inconsistent dimensions!"
+
+        step_vec = np.arange(num_records)
+
+        num_fea_dims = fea_data.shape[1]
+        num_targ_dims = targ_data.shape[1]
+
+        X = []
+        y = []
+        steps = []
+        for i in range(num_records - window_size - horizon_size + 1):
+            fea_seq = fea_data[i : i + window_size]
+            targ_seq = targ_data[
+                i + window_size : i + window_size + horizon_size
+            ]
+
+            assert fea_seq.shape[0] == window_size
+            assert fea_seq.shape[1] == num_fea_dims
+            assert targ_seq.shape[0] == horizon_size
+            assert targ_seq.shape[1] == num_targ_dims
+
+            step_seq = step_vec[
+                i + window_size : i + window_size + horizon_size
+            ]
+
+            assert step_seq.shape[0] == horizon_size
+
+            fea_seq = fea_seq.reshape((num_fea_dims * window_size))
+            targ_seq = targ_seq.reshape((num_targ_dims * horizon_size))
+            step_seq = step_seq.reshape((horizon_size,))
+
+            X.append(fea_seq)
+            y.append(targ_seq)
+            steps.append(step_seq)
+
+        X = np.array(X)
+        y = np.array(y)
+        steps = np.array(steps)
+
+        assert X.shape[0] == y.shape[0]
+        assert len(steps) == X.shape[0]
+
+        assert X.shape[1] == num_fea_dims * window_size
+        assert y.shape[1] == num_targ_dims * horizon_size
+
+        return X, y, steps
+
+    def prep_out_of_sample(
+        self,
+        fea_data: np.array,
+        window_size: int = 1,
+        horizon_size: int = 1,
+    ):
+        num_records = fea_data.shape[0]
+
+        num_fea_dims = fea_data.shape[1]
+
+        fea_seq = fea_data[num_records - window_size : num_records]
+
+        assert fea_seq.shape[0] == window_size
+        assert fea_seq.shape[1] == num_fea_dims
+
+        fea_seq = fea_seq.reshape((num_fea_dims * window_size))
+
+        X = np.array([fea_seq])
+
+        return X
+
+    def generate_pred_df(
+        self,
+        y: np.array,
+        y_pred: np.array,
+        dates: np.array,
+    ):
+        num_records = y.shape[0]
+        num_targ_dims = y.shape[1]
+
+        assert y_pred.shape[0] == num_records
+        assert y_pred.shape[1] == num_targ_dims
+        assert dates.shape[0] == num_records
+        assert dates.shape[1] == num_targ_dims
+
+        tmp_size = num_records * num_targ_dims
+        pred_df = pd.DataFrame(
+            {
+                "Date": dates.reshape((tmp_size)),
+                "Actual": y.reshape((tmp_size)),
+                "Predicted": y_pred.reshape((tmp_size)),
+            }
+        )
+
+        pred_df = pred_df.groupby("Date", as_index=False)[
+            "Actual", "Predicted"
+        ].mean()
+
+        return pred_df
+
+    def get_stats(self, y, y_pred):
+        mape = mean_absolute_percentage_error(y, y_pred)
+        rmse = np.sqrt(mean_squared_error(y, y_pred))
+
+        stats_hash = {"MAPE": mape, "RMSE": rmse}
+
+        return stats_hash
+
+    def fit(self, data: pd.DataFrame):
+        pass
+
+    def predict(self, X: np.array):
+        pass

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

@@ -0,0 +1,220 @@
+# (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 sklearn.preprocessing import MinMaxScaler
+
+from eqc_models.ml.regressorbase import RegressorBase
+
+
+def timer(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        beg_time = time.time()
+        val = func(*args, **kwargs)
+        end_time = time.time()
+        tot_time = end_time - beg_time
+
+        print(
+            "Runtime of %s: %0.2f seconds!"
+            % (
+                func.__name__,
+                tot_time,
+            )
+        )
+
+        return val
+
+    return wrapper
+
+
+class LinearRegression(RegressorBase):
+    """An implementation of linear regression 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.
+
+    l2_reg_coef: L2 regularization penalty multiplier; default: 0.
+
+    alpha: A penalty multiplier to ensure the correct sign of a
+    model parameter; default: 0.
+
+    Examples
+    ---------
+
+    >>> X_train = np.array([[1], [2], [3], [4], [5]])
+    >>> y_train = np.array([3, 5, 7, 9, 11])
+    >>> X_test = np.array([[6], [7], [8]])
+    >>> y_test = np.array([13, 15, 17])
+    >>> from eqc_models.ml.regressor import LinearRegression
+    >>> from contextlib import redirect_stdout    
+    >>> import io
+    >>> f = io.StringIO()
+    >>> with redirect_stdout(f): 
+    ...     model = LinearRegression()
+    ...     model = model.fit(X_train, y_train)
+    ...     y_pred_train = model.predict(X_train)
+    ...     y_pred_test = model.predict(X_test)
+    """
+    
+    def __init__(
+        self,
+        relaxation_schedule=2,
+        num_samples=1,
+        l2_reg_coef=0,
+        alpha=0,
+    ):
+        super(LinearRegression).__init__()
+
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.l2_reg_coef = l2_reg_coef
+        self.alpha = alpha
+        self.params = None
+        self.fit_intercept = None
+        self.resp_transformer = None
+        self.fea_transformer = None
+
+    @timer
+    def fit(self, X, y, fit_intercept=True):
+        """Trains a linear regression 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.
+
+        fit_intercept: A boolean indicating whether an intercept
+        should be fit; default: True.
+
+        Returns
+        -------
+        self : object
+        Fitted estimator.
+
+        """
+
+        assert X.shape[0] == y.shape[0], "Inconsistent sizes!"
+
+        self.fea_transformer = MinMaxScaler(feature_range=(0, 1))
+        X = self.fea_transformer.fit_transform(X)
+
+        self.resp_transformer = MinMaxScaler(feature_range=(0, 1))
+        y = self.resp_transformer.fit_transform(y.reshape(-1, 1)).reshape(
+            -1
+        )
+
+        self.fit_intercept = fit_intercept
+
+        n_records = X.shape[0]
+        if fit_intercept:
+            X = np.concatenate([X, np.ones((n_records, 1))], axis=1)
+
+        n_features = X.shape[1]
+
+        X = np.concatenate([X, -X], axis=1)
+
+        n_dims = X.shape[1]
+
+        assert n_dims == 2 * n_features, "Internal error!"
+
+        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 = self.solve()
+
+        assert len(sol) == C.shape[0], "Inconsistent solution size!"
+
+        self.params = self.convert_sol_to_params(sol)
+
+        return self
+
+    @timer
+    def predict(self, X: np.array):
+        """
+        Predicts output of the regressor for input X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+
+        Returns
+        -------
+        y : ndarray of shape (n_samples,)
+        The predicted raw output of the classifier.
+        """
+
+        if self.params is None:
+            return
+
+        X = self.fea_transformer.transform(X)
+
+        n_records = X.shape[0]
+        if self.fit_intercept:
+            X = np.concatenate([X, np.ones((n_records, 1))], axis=1)
+
+        X = np.concatenate([X, -X], axis=1)
+
+        assert X.shape[1] == len(
+            self.params
+        ), "Inconsistent dimension of X!"
+
+        y = X @ self.params
+
+        assert y.shape[0] == X.shape[0], "Internal error!"
+
+        y = self.resp_transformer.inverse_transform(
+            y.reshape(-1, 1)
+        ).reshape(-1)
+
+        return y
+
+    @timer
+    def get_hamiltonian(
+        self,
+        X: np.array,
+        y: np.array,
+    ):
+        n_dims = X.shape[1]
+
+        J = np.zeros(shape=(n_dims, n_dims), dtype=np.float32)
+        C = np.zeros(shape=(n_dims,), dtype=np.float32)
+
+        for i in range(n_dims):
+            for j in range(n_dims):
+                J[i][j] = np.sum(X.swapaxes(0, 1)[i] * X.swapaxes(0, 1)[j])
+                if i == j:
+                    J[i][j] += self.l2_reg_coef
+
+            C[i] = -2.0 * np.sum(y * X.swapaxes(0, 1)[i])
+
+        C = C.reshape((n_dims, 1))
+
+        # Add sign penalty multiplier
+        n_features = int(n_dims / 2)
+        for i in range(n_features):
+            J[i][i + n_features] += self.alpha
+            J[i + n_features][i] += self.alpha
+
+        return J, C, 1.0
+
+    def convert_sol_to_params(self, sol):
+        return np.array(sol)

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

@@ -0,0 +1,97 @@
+# (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 eqc_models import QuadraticModel
+from eqc_models.solvers.qciclient import Dirac3CloudSolver
+
+
+class RegressorBase(QuadraticModel):
+    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
+        self.params = None
+
+    def predict(self, X: np.array):
+        pass
+
+    def get_hamiltonian(
+        self,
+        X: np.array,
+        y: 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 domains
+        num_variables = C.shape[0]
+        self.domains = sum_constraint * np.ones((num_variables,))
+        
+        return
+
+    def solve(self):
+        solver = Dirac3CloudSolver()
+        response = solver.solve(
+            self,
+            sum_constraint=self._sum_constraint,
+            relaxation_schedule=self.relaxation_schedule,
+            solution_precision=1,
+            num_samples=self.num_samples,
+        )
+
+        min_id = np.argmin(response["results"]["energies"])
+
+        sol = response["results"]["solutions"][min_id]
+
+        print(response)
+        
+        return sol
+
+    def convert_sol_to_params(self, sol):
+        pass
+
+    def fit(self, X, y):
+        return self
+    
+    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)

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

@@ -0,0 +1,106 @@
+import numpy as np
+from emucore_direct.client import EmuCoreClient
+
+# Parameters
+VBIAS = 0.31
+GAIN = 0.72
+FEATURE_SCALING = 0.1
+DENSITY = 1
+
+class QciReservoir:
+    """
+    A class designed as an interface to QCi's reservoir devices.
+
+    Parameters
+    ----------
+        
+    ip_addr: The IP address of the device.
+        
+    num_nodes: Number of reservoir network nodes.
+        
+    vbias: Bias of the reservoir device; default: 0.31. 
+        
+    gain: Gain of the reservoir device; default: 0.72.
+        
+    density: Density used for normalization of the reservoir
+    output; default: 1 (no normalization done).
+        
+    feature_scaling: The factor used to scale the reservoir output; default: 0.1.
+        
+    device: The QCi reservoir device. Currently only 'EmuCore' is
+    supported; default: EmuCore.
+
+    """
+
+    def __init__(
+        self,
+        ip_addr: str,
+        num_nodes: int,
+        vbias: float = VBIAS,
+        gain: float = GAIN,
+        density: float = DENSITY,
+        feature_scaling: float = FEATURE_SCALING,
+        device: str = "EmuCore",
+    ):
+        assert device == "EmuCore", "Unknown device!"
+
+        self.ip_addr = ip_addr
+        self.num_nodes = num_nodes
+        self.vbias = vbias
+        self.gain = gain
+        self.density = density
+        self.feature_scaling = feature_scaling
+        self.device = device
+        self.client = None
+        self.lock_id = None
+        
+    def init_reservoir(self):
+        self.client = EmuCoreClient(ip_addr=self.ip_addr)
+        
+        self.lock_id, _, _ = self.client.wait_for_lock()
+
+        self.client.reservoir_reset(lock_id=self.lock_id)
+        
+        self.client.rc_config(
+            lock_id=self.lock_id,
+            vbias=self.vbias,
+            gain=self.gain,
+            num_nodes=self.num_nodes,
+            num_taps=self.num_nodes,
+        )
+
+    def release_lock(self):
+        self.client.release_lock(lock_id=self.lock_id)
+            
+    def push_reservoir(self, X):
+
+        assert self.client is not None, "The reservoir should be initialized!"
+        assert self.lock_id is not None, "The reservoir should be initialized!"
+        
+        X_resp, _, _ = self.client.process_all_data(
+            input_data=X,
+            num_nodes=self.num_nodes,
+            density=self.density,
+            feature_scaling=self.feature_scaling,
+            lock_id=self.lock_id,
+        )
+
+        return X_resp
+
+    def run_reservoir(self, X_train, X_test=None):
+
+        if X_test is not None:
+            assert X_train.shape[1] == X_test.shape[1]
+
+        num_feas = X_train.shape[1]
+
+
+        X_resp_train = _push_emucore(X_train, lock_id)
+
+        X_resp_test = None
+        if X_test is not None:
+            X_resp_test = _push_emucore(X_test, lock_id)
+
+
+
+        return X_resp_train, X_resp_test

eqc_models-0.9.8.data/platlib/eqc_models/sequence/__init__.py

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