eqc-models 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

{eqc_models-0.13.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/classifierbase.py

@@ -31,10 +31,6 @@ class ClassifierBase(QuadraticModel):
 
         assert solver_access in ["cloud", "direct"]
 
-        if solver_access == "direct":
-            assert ip_addr is not None, "ip_addr should be set when using direct solver!"
-            assert port is not None,"port should be set when using direct solver!"
-            
         self.solver_access = solver_access
         self.ip_addr = ip_addr
         self.port = port

{eqc_models-0.13.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/classifierqboost.py

@@ -16,9 +16,16 @@ from sklearn.naive_bayes import GaussianNB
 from sklearn.linear_model import LogisticRegression
 from sklearn.gaussian_process import GaussianProcessClassifier
 from sklearn.gaussian_process.kernels import RBF
-
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.discriminant_analysis import (
+    LinearDiscriminantAnalysis,
+    QuadraticDiscriminantAnalysis,
+)
+from lightgbm import LGBMClassifier
+from xgboost import XGBClassifier
 from eqc_models.ml.classifierbase import ClassifierBase
-#from eqc_models.ml.cvqboost_hamiltonian import get_hamiltonian_pyx
+
+# from eqc_models.ml.cvqboost_hamiltonian import get_hamiltonian_pyx
 
 
 def timer(func):
@@ -48,8 +55,7 @@ class WeakClassifier:
         X_train,
         y_train,
         weak_cls_type,
-        max_depth=10,
-        min_samples_split=100,
+        weak_cls_params={},
         num_jobs=1,
     ):
         assert X_train.shape[0] == len(y_train)
@@ -58,30 +64,34 @@ class WeakClassifier:
         self.y_train = y_train
 
         if weak_cls_type == "dct":
-            self.clf = DecisionTreeClassifier(
-                max_depth=max_depth,
-                min_samples_split=min_samples_split,
-                random_state=0,
-            )
+            self.clf = DecisionTreeClassifier(**weak_cls_params)
         elif weak_cls_type == "nb":
-            self.clf = GaussianNB()
+            self.clf = GaussianNB(**weak_cls_params)
         elif weak_cls_type == "lg":
-            self.clf = LogisticRegression(random_state=0)
+            self.clf = LogisticRegression(**weak_cls_params)
         elif weak_cls_type == "gp":
-            self.clf = GaussianProcessClassifier(
-                kernel=1.0 * RBF(1.0),
-                random_state=0,
-            )
+            self.clf = GaussianProcessClassifier(**weak_cls_params)
+        elif weak_cls_type == "knn":
+            self.clf = KNeighborsClassifier(**weak_cls_params)
+        elif weak_cls_type == "lda":
+            self.clf = LinearDiscriminantAnalysis(**weak_cls_params)
+        elif weak_cls_type == "qda":
+            self.clf = QuadraticDiscriminantAnalysis(**weak_cls_params)
+        elif weak_cls_type == "lgb":
+            self.clf = LGBMClassifier(**weak_cls_params)
+        elif weak_cls_type == "xgb":
+            self.clf = XGBClassifier(**weak_cls_params)
         else:
             assert False, (
                 "Unknown weak classifier type <%s>!" % weak_cls_type
             )
 
     def train(self):
-        self.clf.fit(self.X_train, self.y_train)
+        self.clf.fit(self.X_train, np.where(self.y_train == -1, 0, 1))
 
     def predict(self, X):
-        return self.clf.predict(X)
+        y_pred = self.clf.predict(X)
+        return np.where(y_pred == 0, -1, 1)
 
 
 class QBoostClassifier(ClassifierBase):
@@ -97,9 +107,9 @@ class QBoostClassifier(ClassifierBase):
     solver_access: Solver access type: cloud or direct; default: cloud.
 
     ip_addr: IP address of the device when direct access is used; default: None.
-    
-    port: Port number of the device when direct access is used; default: None.    
-    
+
+    port: Port number of the device when direct access is used; default: None.
+
     lambda_coef: A penalty multiplier; default: 0.
 
     weak_cls_schedule: Weak classifier schedule. Is either 1, 2,
@@ -110,15 +120,24 @@ class QBoostClassifier(ClassifierBase):
         - nb: Naive Baysian classifier
         - lg: Logistic regression
         - gp: Gaussian process classifier
+        - knn: K-nearest neighbors classifier
+        - lda: Linear discriminant analysis classifier
+        - qda: Quadratic discriminant analysis classifier
+        - lgb: Light-GBM classifier
+        - xgb: XGBoost classifier
+
+    default: lg.
 
-    default: dct.
+    weak_cls_params: Dict of weak classifier parameters. Default: {};
+    use default parameters.
 
-    weak_max_depth: Max depth of the tree. Applied only when
-    weak_cls_type="dct". Default: 10.
+    weak_cls_strategy: Computation strategy for weak classifier
+    training, either "sequential" or "multi_processing". Default:
+    "multi_processing".
 
-    weak_min_samples_split: The minimum number of samples required
-    to split an internal node. Applied only when
-    weak_cls_type="dct". Default: 100.
+    weak_cls_num_jobs: Number of jobs when
+    weak_cls_strategy="multi_processing". Default: None; use all
+    available cores.
 
     Examples
     -----------
@@ -155,6 +174,7 @@ class QBoostClassifier(ClassifierBase):
     ...    obj.fit(X_train, y_train)
     ...    y_train_prd = obj.predict(X_train)
     ...    y_test_prd = obj.predict(X_test)
+
     """
 
     def __init__(
@@ -165,24 +185,35 @@ class QBoostClassifier(ClassifierBase):
         ip_addr=None,
         port=None,
         lambda_coef=0,
-        weak_cls_schedule=2,
+        weak_cls_schedule=1,
         weak_cls_type="lg",
-        weak_max_depth=10,
-        weak_min_samples_split=100,
+        weak_cls_params={},
         weak_cls_strategy="multi_processing",
         weak_cls_num_jobs=None,
+        weak_cls_pair_count=None,
     ):
         super(QBoostClassifier).__init__()
 
         assert weak_cls_schedule in [1, 2, 3]
-        assert weak_cls_type in ["dct", "nb", "lg", "gp"]
+        assert weak_cls_type in [
+            "dct",
+            "nb",
+            "lg",
+            "gp",
+            "knn",
+            "lda",
+            "qda",
+            "lgb",
+            "xgb",
+        ]
+
         assert weak_cls_strategy in [
             "multi_processing",
             "multi_processing_shm",
             "sequential",
         ]
         assert solver_access in ["cloud", "direct"]
-        
+
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
         self.solver_access = solver_access
@@ -191,18 +222,29 @@ class QBoostClassifier(ClassifierBase):
         self.lambda_coef = lambda_coef
         self.weak_cls_schedule = weak_cls_schedule
         self.weak_cls_type = weak_cls_type
-        self.weak_max_depth = weak_max_depth
-        self.weak_min_samples_split = weak_min_samples_split
+        self.weak_cls_params = weak_cls_params
         self.weak_cls_strategy = weak_cls_strategy
         if weak_cls_num_jobs is None or weak_cls_num_jobs <= 0:
             self.weak_cls_num_jobs = os.cpu_count()
         else:
             self.weak_cls_num_jobs = int(weak_cls_num_jobs)
+        self.weak_cls_pair_count = weak_cls_pair_count
 
         self.h_list = []
         self.ind_list = []
         self.classes_ = None
 
+    def topNPairs(self, X, n):
+        assert n < X.shape[1]*(X.shape[1]-1)
+        cov = np.corrcoef(X, rowvar=False)
+        abscov = np.abs(cov)
+        flatcov = []
+        for i in range(X.shape[1]):
+            for j in range(i+1, X.shape[1]):
+                flatcov.append((abscov[i, j], (i, j)))
+        flatcov.sort()
+        return [idx for val, idx in flatcov[-n:]]
+
     @timer
     def _build_weak_classifiers_sq(self, X, y):
         n_records = X.shape[0]
@@ -221,26 +263,33 @@ class QBoostClassifier(ClassifierBase):
                 X[:, [l]],
                 y,
                 self.weak_cls_type,
-                self.weak_max_depth,
-                self.weak_min_samples_split,
+                self.weak_cls_params,
             )
             weak_classifier.train()
             self.ind_list.append([l])
             self.h_list.append(weak_classifier)
 
         if self.weak_cls_schedule >= 2:
-            for i in range(n_dims):
-                for j in range(i + 1, n_dims):
-                    weak_classifier = WeakClassifier(
-                        X[:, [i, j]],
-                        y,
-                        self.weak_cls_type,
-                        self.weak_max_depth,
-                        self.weak_min_samples_split,
-                    )
-                    weak_classifier.train()
-                    self.ind_list.append([i, j])
-                    self.h_list.append(weak_classifier)
+            """
+            Use up to weak_cls_pair_count pairs, ordered by absolute covariance
+
+            """
+            if self.weak_cls_pair_count is None:
+                weak_cls_pair_count = n_dims * (n_dims - 1)
+            else:
+                weak_cls_pair_count = self.weak_cls_pair_count
+            pairs = self.topNPairs(X, weak_cls_pair_count)
+            for i, j in pairs:
+                weak_classifier = WeakClassifier(
+                    X[:, [i, j]],
+                    y,
+                    self.weak_cls_type,
+                    self.weak_max_depth,
+                    self.weak_min_samples_split,
+                )
+                weak_classifier.train()
+                self.ind_list.append([i, j])
+                self.h_list.append(weak_classifier)
 
         if self.weak_cls_schedule >= 3:
             for i in range(n_dims):
@@ -250,8 +299,7 @@ class QBoostClassifier(ClassifierBase):
                             X[:, [i, j, k]],
                             y,
                             self.weak_cls_type,
-                            self.weak_max_depth,
-                            self.weak_min_samples_split,
+                            self.weak_cls_params,
                         )
                         weak_classifier.train()
                         self.ind_list.append([i, j, k])
@@ -267,16 +315,14 @@ class QBoostClassifier(ClassifierBase):
         n_records,
         n_dims,
         weak_cls_type,
-        weak_max_depth,
-        weak_min_samples_split,
+        weak_cls_params,
     ):
         # Train the weak classifier
         weak_classifier = WeakClassifier(
             X_subset,
             y,
             weak_cls_type,
-            weak_max_depth,
-            weak_min_samples_split,
+            weak_cls_params,
         )
         weak_classifier.train()
 
@@ -307,8 +353,7 @@ class QBoostClassifier(ClassifierBase):
                     n_records,
                     n_dims,
                     self.weak_cls_type,
-                    self.weak_max_depth,
-                    self.weak_min_samples_split,
+                    self.weak_cls_params,
                 )
             )
 
@@ -323,8 +368,7 @@ class QBoostClassifier(ClassifierBase):
                             n_records,
                             n_dims,
                             self.weak_cls_type,
-                            self.weak_max_depth,
-                            self.weak_min_samples_split,
+                            self.weak_cls_params,
                         )
                     )
 
@@ -340,8 +384,7 @@ class QBoostClassifier(ClassifierBase):
                                 n_records,
                                 n_dims,
                                 self.weak_cls_type,
-                                self.weak_max_depth,
-                                self.weak_min_samples_split,
+                                self.weak_cls_params,
                             )
                         )
 
@@ -367,8 +410,7 @@ class QBoostClassifier(ClassifierBase):
         n_records,
         n_dims,
         weak_cls_type,
-        weak_max_depth,
-        weak_min_samples_split,
+        weak_cls_params,
     ):
         """Train a weak classifier using shared memory."""
 
@@ -386,8 +428,7 @@ class QBoostClassifier(ClassifierBase):
             X_subset,
             y_shared,
             weak_cls_type,
-            weak_max_depth,
-            weak_min_samples_split,
+            weak_cls_params,
         )
         weak_classifier.train()
 
@@ -437,8 +478,7 @@ class QBoostClassifier(ClassifierBase):
                             n_records,
                             n_dims,
                             self.weak_cls_type,
-                            self.weak_max_depth,
-                            self.weak_min_samples_split,
+                            self.weak_cls_params,
                         )
                     )
 
@@ -454,8 +494,7 @@ class QBoostClassifier(ClassifierBase):
                                     n_records,
                                     n_dims,
                                     self.weak_cls_type,
-                                    self.weak_max_depth,
-                                    self.weak_min_samples_split,
+                                    self.weak_cls_params,
                                 )
                             )
 
@@ -472,8 +511,7 @@ class QBoostClassifier(ClassifierBase):
                                         n_records,
                                         n_dims,
                                         self.weak_cls_type,
-                                        self.weak_max_depth,
-                                        self.weak_min_samples_split,
+                                        self.weak_cls_params,
                                     )
                                 )
 
@@ -581,7 +619,7 @@ class QBoostClassifier(ClassifierBase):
 
         return y
 
-    def predict(self, X: np.array):
+    def predict(self, X: np.array, threshold=0):
         """
         Predict classes for X.
 
@@ -589,6 +627,8 @@ class QBoostClassifier(ClassifierBase):
         ----------
         X : {array-like, sparse matrix} of shape (n_samples, n_features)
 
+        threshold: Prediction threshold.
+
         Returns
         -------
         y : ndarray of shape (n_samples,)
@@ -596,7 +636,9 @@ class QBoostClassifier(ClassifierBase):
         """
 
         y = self.predict_raw(X)
-        y = np.sign(y)
+
+        y[y < threshold] = -1
+        y[y >= threshold] = 1
 
         return y
 
@@ -628,9 +670,10 @@ class QBoostClassifier(ClassifierBase):
         )
 
         J = np.tensordot(h_vals, h_vals, axes=(1, 1))
+        J = J.astype(np.float64)
         J += np.diag(self.lambda_coef * np.ones((n_classifiers)))
         C = -2.0 * np.tensordot(h_vals, y, axes=(1, 0))
-        
+
         # J, C = get_hamiltonian_pyx(y, h_vals, self.lambda_coef, n_records)
 
         C = C.reshape((n_classifiers, 1))

{eqc_models-0.13.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/clustering.py

@@ -24,6 +24,12 @@ class GraphClustering(ClusteringBase):
     
     device: The device used, dirac-1 or dirac-3; default: dirac-3.
 
+    solver_access: Solver access type: cloud or direct; default: cloud.
+
+    ip_addr: IP address of the device when direct access is used; default: None.
+
+    port: Port number of the device when direct access is used; default: None.
+    
     Examples
     ---------
 
@@ -64,11 +70,16 @@ class GraphClustering(ClusteringBase):
         relaxation_schedule=2,
         num_samples=1,
         device="dirac-3",
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,            
     ):
         super(GraphClustering).__init__()
 
         assert device in ["dirac-1", "dirac-3"]
 
+        assert solver_access in ["cloud", "direct"]
+        
         self.graph = graph
         self.num_nodes = graph.number_of_nodes()
         self.num_edges = graph.number_of_edges()
@@ -77,6 +88,9 @@ class GraphClustering(ClusteringBase):
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
         self.device = device
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port        
         self.labels = None
 
     def get_hamiltonian(self):
@@ -188,7 +202,13 @@ class Clustering(ClusteringBase):
     distance_func: Distance function used; default: squared_l2_norm.
     
     device: The device used, dirac-1 or dirac-3; default: dirac-3.
- 
+
+    solver_access: Solver access type: cloud or direct; default: cloud.
+
+    ip_addr: IP address of the device when direct access is used; default: None.
+
+    port: Port number of the device when direct access is used; default: None.
+    
     Examples
     ---------
 
@@ -222,17 +242,25 @@ class Clustering(ClusteringBase):
         num_samples: int = 1,
         distance_func: str = "squared_l2_norm",
         device: str = "dirac-3",
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,            
     ):
         super(Clustering).__init__()
 
         assert device in ["dirac-1", "dirac-3"]
 
+        assert solver_access in ["cloud", "direct"]
+        
         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.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port        
         self.labels = None
 
         assert distance_func in ["squared_l2_norm"], (

{eqc_models-0.13.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/clusteringbase.py

@@ -7,7 +7,7 @@ from eqc_models.solvers.qciclient import (
     Dirac1CloudSolver,
     Dirac3CloudSolver,
 )
-
+from eqc_models.solvers.eqcdirect import Dirac3DirectSolver
 
 class ClusteringBase(QuadraticModel):
     """
@@ -19,14 +19,26 @@ class ClusteringBase(QuadraticModel):
         relaxation_schedule=2,
         num_samples=1,
         device="dirac-3",
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,            
     ):
         super(self).__init__(None, None, None)
 
         assert device in ["dirac-1", "dirac-3"]
 
+        assert solver_access in ["cloud", "direct"]
+
+        if device == "dirac-1" and solver_access == "direct":
+            print("Dirac-1 is only available on cloud")
+            solver_access = "cloud"
+        
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
         self.device = device
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port
 
     def fit(self, X: np.array):
         pass
@@ -63,7 +75,12 @@ class ClusteringBase(QuadraticModel):
                 num_samples=self.num_samples,
             )
         elif self.device == "dirac-3":
-            solver = Dirac3CloudSolver()
+            if self.solver_access == "direct":
+                solver = Dirac3DirectSolver()
+                solver.connect(self.ip_addr, self.port)
+            else:
+                solver = Dirac3CloudSolver()
+                
             response = solver.solve(
                 self,
                 sum_constraint=self._sum_constraint,
@@ -71,10 +88,16 @@ class ClusteringBase(QuadraticModel):
                 num_samples=self.num_samples,
             )
 
-        min_id = np.argmin(response["results"]["energies"])
-
-        sol = response["results"]["solutions"][min_id]
-
+        if self.solver_access == "cloud":
+            energies = response["results"]["energies"]
+            solutions = response["results"]["solutions"]
+        elif self.solver_access == "direct":
+            energies = response["energy"]
+            solutions = response["solution"]
+            
+        min_id = np.argmin(energies)
+        sol = solutions[min_id]
+            
         print(response)
 
         return sol, response

{eqc_models-0.13.0.data → eqc_models-0.14.0.data}/platlib/eqc_models/ml/decomposition.py

@@ -14,10 +14,8 @@ from qci_client import QciClient
 from eqc_models import QuadraticModel
 from eqc_models.solvers.qciclient import (
     Dirac3CloudSolver,
-    Dirac3ContinuousCloudSolver,
-    Dirac1CloudSolver,
 )
-
+from eqc_models.solvers.eqcdirect import Dirac3DirectSolver
 
 class DecompBase(QuadraticModel):
     """An Base class for decomposition algorithms.
@@ -30,17 +28,30 @@ class DecompBase(QuadraticModel):
 
     num_samples: Number of samples used by Dirac-3; default: 1.
 
+    solver_access: Solver access type: cloud or direct; default: cloud.
+
+    ip_addr: IP address of the device when direct access is used; default: None.
+
+    port: Port number of the device when direct access is used; default: None.    
     """
 
     def __init__(
         self,
         relaxation_schedule=2,
         num_samples=1,
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,                        
     ):
         super(self).__init__(None, None, None)
 
+        assert solver_access in ["cloud", "direct"]
+        
         self.relaxation_schedule = relaxation_schedule
         self.num_samples = num_samples
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port
 
     def _get_hamiltonian(
         self,
@@ -62,15 +73,31 @@ class DecompBase(QuadraticModel):
         return
 
     def _solve(self):
-        solver = Dirac3ContinuousCloudSolver()
+
+        if self.solver_access == "direct":
+            solver = Dirac3DirectSolver()
+            solver.connect(self.ip_addr, self.port)
+        else:
+            solver = Dirac3CloudSolver()
+                
         response = solver.solve(
             self,
-            relaxation_schedule=self.relaxation_schedule,
             sum_constraint=self._sum_constraint,
+            relaxation_schedule=self.relaxation_schedule,
             num_samples=self.num_samples,
         )
 
-        sol = response["results"]["solutions"][0]
+        if self.solver_access == "cloud":
+            energies = response["results"]["energies"]
+            solutions = response["results"]["solutions"]
+        elif self.solver_access == "direct":
+            energies = response["energy"]
+            solutions = response["solution"]
+            
+        min_id = np.argmin(energies)
+        sol = solutions[min_id]
+            
+        print(response)
 
         return sol, response
 
@@ -180,6 +207,12 @@ class PCA(DecompBase):
 
     num_samples: Number of samples used by Dirac-3; default: 1.
 
+    solver_access: Solver access type: cloud or direct; default: cloud.
+
+    ip_addr: IP address of the device when direct access is used; default: None.
+
+    port: Port number of the device when direct access is used; default: None.
+    
     mode: Compute the largest or smallest principal components,
     largest_components vs. smallest_components; default:
     largest_components.
@@ -212,16 +245,23 @@ class PCA(DecompBase):
         n_components=None,
         relaxation_schedule=2,
         num_samples=1,
+        solver_access="cloud",
+        ip_addr=None,
+        port=None,                        
         mode="largest_components",
     ):
-        self.n_components = n_components
-        self.relaxation_schedule = relaxation_schedule
-        self.num_samples = num_samples
 
+        assert solver_access in ["cloud", "direct"]
         assert mode in ["largest_components", "smallest_components"], (
             "Invalid value of mode <%s>" % mode
         )
-
+        
+        self.n_components = n_components
+        self.relaxation_schedule = relaxation_schedule
+        self.num_samples = num_samples
+        self.solver_access = solver_access
+        self.ip_addr = ip_addr
+        self.port = port        
         self.mode = mode
         self.X = None
         self.X_pca = None