eqc-models 0.9.8__py3-none-any.whl

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

@@ -0,0 +1,237 @@
+# (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.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.
+    
+    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
+    -----------
+
+    >>> 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,
+    ...     upper_limit=1.0,
+    ...     gamma=1.0,
+    ...     eta=1.0,
+    ...     zeta=1.0,
+    ... )
+    >>> 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=2,
+        num_samples=1,
+        upper_limit=1.0,
+        gamma=1.0,
+        eta=1.0,
+        zeta=1.0,
+    ):        
+        super(QSVMClassifier).__init__()
+
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.upper_limit = upper_limit
+        self.gamma = gamma
+        self.eta = eta
+        self.zeta = zeta
+
+    def kernel(self, vec1, vec2):
+        return np.exp(-self.gamma * np.linalg.norm(vec1 - vec2) ** 2)
+
+    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}"
+
+        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
+
+        n_records = X.shape[0]
+        self.kernel_mat_train = np.zeros(
+            shape=(n_records, n_records), dtype=np.float32
+        )
+        for m in range(n_records):
+            for n in range(n_records):
+                self.kernel_mat_train[m][n] = self.kernel(X[m], X[n])
+
+        return response
+
+    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!"
+
+        assert (
+            X.shape[1] == self.X_train.shape[1]
+        ), "Inconsistent dimensions!"
+
+        n_records = X.shape[0]
+        n_records_train = self.X_train.shape[0]
+        kernel_mat = np.zeros(
+            shape=(n_records, n_records_train), dtype=np.float32
+        )
+        for m in range(n_records):
+            for n in range(n_records_train):
+                kernel_mat[m][n] = self.kernel(X[m], self.X_train[n])
+
+        intercept = 0
+        tmp_vec1 = np.tensordot(
+            self.params * self.y_train, self.kernel_mat_train, axes=(0, 0)
+        )
+        assert tmp_vec1.shape[0] == n_records_train, "Inconsistent size!"
+
+        tmp1 = np.sum(
+            self.params
+            * (self.upper_limit - self.params)
+            * (self.y_train - tmp_vec1)
+        )
+        tmp2 = np.sum(self.params * (self.upper_limit - self.params))
+
+        assert tmp2 != 0, "Something went wrong!"
+
+        intercept = tmp1 / tmp2
+
+        y = np.zeros(shape=(n_records), dtype=np.float32)
+        y += np.tensordot(
+            self.params * self.y_train, kernel_mat, axes=(0, 1)
+        )
+        y += intercept
+        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=(2 * n_records, 2 * n_records), dtype=np.float32
+        )
+        C = np.zeros(shape=(2 * n_records,), dtype=np.float32)
+
+        for n in range(n_records):
+            for m in range(n_records):
+                J[n][m] = (
+                    0.5 * y[n] * y[m] * self.kernel(X[n], X[m])
+                    + self.zeta * y[n] * y[m]
+                )
+            J[n][n] += self.eta
+            J[n][n + n_records] = self.eta
+            J[n + n_records][n] = self.eta
+            J[n + n_records][n + n_records] = self.eta
+
+            C[n] = -1.0 - 2.0 * self.eta * self.upper_limit
+            C[n + n_records] = -2.0 * self.eta * self.upper_limit
+
+        C = C.reshape((2 * n_records, 1))
+        J = 0.5 * (J + J.transpose())
+
+        return J, C, n_records * self.upper_limit
+
+    def convert_sol_to_params(self, sol):
+        assert len(sol) % 2 == 0, "Expected an even solution size!"
+
+        sol = sol[: int(len(sol) / 2)]
+
+        return np.array(sol)

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

@@ -0,0 +1,323 @@
+import sys
+import numpy as np
+import networkx as nx
+
+from eqc_models.ml.clusteringbase import ClusteringBase
+
+
+class GraphClustering(ClusteringBase):
+    """
+    A clustering approach on a graph based on maximizing modularity.
+
+    Parameters
+    ----------
+    
+    graph: A NetwrokX graph object representing the data.
+    num_clusters: Number of clusters.
+    
+    alpha: A penalty term multilplier; default: 1.0.
+    
+    relaxation_schedule: Relaxation schedule used by Dirac-3; default:
+    2.
+    
+    num_samples: Number of samples used by Dirac-3; default: 1.
+    
+    device: The device used, dirac-1 or dirac-3; default: dirac-3.
+
+    Examples
+    ---------
+
+    >>> import networkx as nx
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=5)
+    >>> G.add_edge(2, 3, weight=3)
+    >>> G.add_edge(1, 3, weight=4)
+    >>> G.add_edge(4, 5, weight=6)
+    >>> G.add_edge(5, 6, weight=2)
+    >>> G.add_edge(4, 6, weight=7)
+    >>> G.add_edge(7, 8, weight=8)
+    >>> G.add_edge(8, 9, weight=1)
+    >>> G.add_edge(7, 9, weight=5)
+    >>> G.add_edge(3, 4, weight=0.5)
+    >>> G.add_edge(6, 7, weight=0.5)
+    >>> from eqc_models.ml.clustering import GraphClustering    
+    >>> from contextlib import redirect_stdout
+    >>> import io
+    >>> f = io.StringIO()
+    >>> with redirect_stdout(f):
+    ...     obj = GraphClustering(
+    ...         relaxation_schedule=2,
+    ...         num_samples=1,
+    ...         graph=G,
+    ...         num_clusters=3,
+    ...         alpha=10.0,
+    ...         device="dirac-3",    
+    ...     )
+    ...     labels = obj.fit_predict()
+    """
+
+    def __init__(
+        self,
+        graph: nx.Graph,
+        num_clusters: int,
+        alpha: float = 1.0,
+        relaxation_schedule=2,
+        num_samples=1,
+        device="dirac-3",
+    ):
+        super(GraphClustering).__init__()
+
+        assert device in ["dirac-1", "dirac-3"]
+
+        self.graph = graph
+        self.num_nodes = graph.number_of_nodes()
+        self.num_edges = graph.number_of_edges()
+        self.num_clusters = num_clusters
+        self.alpha = alpha
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.device = device
+        self.labels = None
+
+    def get_hamiltonian(self):
+        adj_mat_sparse = nx.adjacency_matrix(self.graph)
+        A = adj_mat_sparse.toarray()
+
+        assert A.shape[0] == A.shape[1], "Inconsistent size!"
+        assert A.shape[0] == self.num_nodes, "Inconsistent size!"
+
+        num_clusters = self.num_clusters
+        num_nodes = self.num_nodes
+
+        J = np.zeros(
+            shape=(num_nodes * num_clusters, num_nodes * num_clusters),
+            dtype=np.float64,
+        )
+        C = np.zeros(
+            shape=(num_nodes * num_clusters),
+            dtype=np.float64,
+        )
+
+        for i in range(num_nodes):
+            for j in range(num_nodes):
+                for c in range(num_clusters):
+                    for d in range(num_clusters):
+                        if c == d:
+                            J[i * num_clusters + c][
+                                j * num_clusters + d
+                            ] += -(
+                                A[i][j]
+                                - np.sum(A[i]) * np.sum(A[j]) / np.sum(A)
+                            )
+                        if i == j:
+                            J[i * num_clusters + c][
+                                j * num_clusters + d
+                            ] += self.alpha
+
+        for i in range(num_nodes):
+            for c in range(num_clusters):
+                C[i * num_clusters + c] += -2.0 * self.alpha
+
+        return J, C, num_nodes
+
+    def get_labels(self, sol: np.array):
+        labels = np.empty(shape=(self.num_nodes), dtype=np.int32)
+
+        for i in range(self.num_nodes):
+            vec = sol[i * self.num_clusters : (i + 1) * self.num_clusters]
+            labels[i] = np.argmax(vec) + 1
+
+        return labels
+
+    def fit(self):
+        """
+        Fit clustering.
+        """
+        J, C, sum_constraint = self.get_hamiltonian()
+
+        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!"
+        assert len(sol) == self.num_clusters * self.num_nodes
+
+        self.labels = self.get_labels(sol)
+
+        return self
+
+    def fit_predict(self):
+        """
+        Fit clustering and return cluster labels for all nodes.
+        """
+
+        self.fit()
+
+        return self.labels
+
+    def get_modularity(self):
+        if self.labels is None:
+            return
+
+        clusters = [set() for i in range(self.num_clusters)]
+        nodes = list(self.graph.nodes())
+        for i in range(self.num_nodes):
+            clusters[self.labels[i] - 1].add(nodes[i])
+
+        return nx.community.modularity(self.graph, clusters)
+
+
+class Clustering(ClusteringBase):
+    """A clustering approach based on QCi's Dirac machines.
+
+    Parameters
+    ----------
+    
+    num_clusters: Number of clusters.
+    
+    alpha: A penalty term multilplier; default: 1.0.
+    
+    relaxation_schedule: Relaxation schedule used by Dirac-3; default:
+    2.
+    
+    num_samples: Number of samples used by Dirac-3; default: 1.
+    
+    distance_func: Distance function used; default: squared_l2_norm.
+    
+    device: The device used, dirac-1 or dirac-3; default: dirac-3.
+ 
+    Examples
+    ---------
+
+    >>> np.random.seed(42)
+    >>> cluster1 = np.random.randn(15, 2) * 0.5 + np.array([2, 2])
+    >>> cluster2 = np.random.randn(15, 2) * 0.5 + np.array([8, 3])
+    >>> cluster3 = np.random.randn(15, 2) * 0.5 + np.array([5, 8])
+    >>> X = np.vstack((cluster1, cluster2, cluster3))
+    >>> from eqc_models.ml.clustering import Clustering    
+    >>> from contextlib import redirect_stdout
+    >>> import io
+    >>> f = io.StringIO()
+    >>> with redirect_stdout(f):
+    ...    obj = Clustering(
+    ...        num_clusters=3,
+    ...        relaxation_schedule=1,
+    ...        num_samples=1,
+    ...        alpha=500.0,
+    ...        distance_func="squared_l2_norm",
+    ...        device="dirac-3",
+    ...    )
+    ...    labels = obj.fit_predict(X)
+
+    """
+
+    def __init__(
+        self,
+        num_clusters: int,
+        alpha: float = 1.0,
+        relaxation_schedule: int = 2,
+        num_samples: int = 1,
+        distance_func: str = "squared_l2_norm",
+        device: str = "dirac-3",
+    ):
+        super(Clustering).__init__()
+
+        assert device in ["dirac-1", "dirac-3"]
+
+        self.num_clusters = num_clusters
+        self.alpha = alpha
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.distance_func = distance_func
+        self.device = device
+        self.labels = None
+
+        assert distance_func in ["squared_l2_norm"], (
+            "Unknown distance function <%s>!" % distance_func
+        )
+
+    def get_hamiltonian(self, X: np.array):
+        num_items = X.shape[0]
+        num_clusters = self.num_clusters
+
+        if self.distance_func == "squared_l2_norm":
+            dist = lambda u, v: np.linalg.norm(u - v) ** 2
+
+        J = np.zeros(
+            shape=(num_items * num_clusters, num_items * num_clusters),
+            dtype=np.float64,
+        )
+        C = np.zeros(
+            shape=(num_items * num_clusters),
+            dtype=np.float64,
+        )
+
+        for i in range(num_items):
+            for j in range(num_items):
+                for c in range(num_clusters):
+                    for d in range(num_clusters):
+                        if c == d:
+                            J[i * num_clusters + c][
+                                j * num_clusters + d
+                            ] += dist(X[i], X[j])
+
+                        if i == j:
+                            J[i * num_clusters + c][
+                                j * num_clusters + d
+                            ] += self.alpha
+
+        for i in range(num_items):
+            for c in range(num_clusters):
+                C[i * num_clusters + c] += -2.0 * self.alpha
+
+        return J, C, num_items
+
+    def get_labels(self, sol: np.array, num_items: int):
+        labels = np.empty(shape=(num_items), dtype=np.int32)
+
+        for i in range(num_items):
+            vec = sol[i * self.num_clusters : (i + 1) * self.num_clusters]
+            labels[i] = np.argmax(vec) + 1
+
+        return labels
+
+    def fit(self, X: np.array):
+        """
+        Fit clustering.
+
+        Parameters
+        ----------
+        X: Dataset; an array of shape (num_items, num_dims).
+        """
+        num_items = X.shape[0]
+        J, C, sum_constraint = 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, sum_constraint)
+
+        sol = self.solve()
+
+        assert len(sol) == C.shape[0], "Inconsistent solution size!"
+        assert len(sol) == self.num_clusters * num_items
+
+        self.labels = self.get_labels(sol, num_items)
+
+        return self
+
+    def fit_predict(self, X: np.array):
+        """
+        Fit clustering and return cluster labels for all records.
+
+        Parameters
+        ----------
+        X: Dataset; an array of shape (num_items, num_dims).
+        """
+
+        self.fit(X)
+
+        return self.labels

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

@@ -0,0 +1,112 @@
+# (C) Quantum Computing Inc., 2024.
+import sys
+import numpy as np
+
+from eqc_models import QuadraticModel
+from eqc_models.solvers.qciclient import (
+    Dirac1CloudSolver,
+    Dirac3CloudSolver,
+)
+
+
+class ClusteringBase(QuadraticModel):
+    """
+    A base class for clustering algorithms
+    """
+
+    def __init__(
+        self,
+        relaxation_schedule=2,
+        num_samples=1,
+        device="dirac-3",
+    ):
+        super(self).__init__(None, None, None)
+
+        assert device in ["dirac-1", "dirac-3"]
+
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.device = device
+
+    def fit(self, X: np.array):
+        pass
+
+    def predict(self, X: np.array):
+        pass
+
+    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
+        num_variables = C.shape[0]
+
+        if self.device == "dirac-1":
+            self.upper_bound = np.ones((num_variables,))
+        elif self.device == "dirac-3":
+            self.upper_bound = sum_constraint * np.ones((num_variables,))
+
+        return
+
+    def solve(self):
+        if self.device == "dirac-1":
+            solver = Dirac1CloudSolver()
+            response = solver.solve(
+                self,
+                num_samples=self.num_samples,
+            )
+        elif self.device == "dirac-3":
+            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 get_labels(self, sol):
+        pass
+
+    def get_energy(self, sol: np.array):
+        C = self._C
+        J = self._J
+
+        return sol.transpose() @ J @ sol + sol.transpose @ C
+
+    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)