test with sklearn default

Author: saroudant

sobolev_alignment/krr_approx.py

@@ -30,7 +30,10 @@
     from falkon import Falkon
     from falkon.kernels import GaussianKernel, LaplacianKernel, MaternKernel
     from falkon.options import FalkonOptions
+
+    FALKON_IMPORTED = True
 except ImportError:
+    FALKON_IMPORTED = False
     print("FALKON NOT INSTALLED, OR NOT IMPORTED. USING FALKON WOULD RESULT IN BETTER PERFORMANCE.", flush=True)
 from sklearn.gaussian_process.kernels import Matern, PairwiseKernel
 from sklearn.kernel_ridge import KernelRidge
@@ -58,10 +61,10 @@ class KRRApprox:
     }
 
     falkon_kernel = {
-        "rbf": GaussianKernel,
-        "gaussian": GaussianKernel,
-        "laplacian": LaplacianKernel,
-        "matern": MaternKernel,
+        "rbf": GaussianKernel if FALKON_IMPORTED else None,
+        "gaussian": GaussianKernel if FALKON_IMPORTED else None,
+        "laplacian": LaplacianKernel if FALKON_IMPORTED else None,
+        "matern": MaternKernel if FALKON_IMPORTED else None,
     }
 
     default_kernel_params = {
@@ -244,7 +247,7 @@ def _setup_falkon_clf(self):
             penalty=self.penalization,
             M=self.M,
             maxiter=self.maxiter,
-            options=FalkonOptions(**self.falkon_options),
+            options=FalkonOptions(**self.falkon_options) if FALKON_IMPORTED else None,
         )
         return True
 

tests/test_krr_approx.py

@@ -13,6 +13,14 @@
 M = 500
 
 
+@pytest.fixture(scope="module")
+def falkon_import():
+    try:
+        return True
+    except ImportError:
+        return False
+
+
 @pytest.fixture(scope="module")
 def input():
     return torch.normal(0, 1, size=(n_samples, n_genes))
@@ -81,41 +89,60 @@ def fit_sklearn_matern_ridge(self, sklearn_matern_KRR, input, embedding):
     ###
 
     @pytest.fixture(scope="class")
-    def falkon_rbf_KRR(self):
-        return KRRApprox(
-            method="falkon", kernel="rbf", kernel_params={"sigma": np.sqrt(2 * n_genes)}, penalization=penalization, M=M
-        )
+    def falkon_rbf_KRR(self, falkon_import):
+        if falkon_import:
+            return KRRApprox(
+                method="falkon",
+                kernel="rbf",
+                kernel_params={"sigma": np.sqrt(2 * n_genes)},
+                penalization=penalization,
+                M=M,
+            )
+        else:
+            return None
 
     @pytest.fixture(scope="class")
-    def falkon_matern_KRR(self):
-        return KRRApprox(
-            method="falkon",
-            kernel="matern",
-            kernel_params={"sigma": np.sqrt(2 * n_genes), "nu": 1.5},
-            penalization=penalization,
-            M=M,
-        )
+    def falkon_matern_KRR(self, falkon_import):
+        if falkon_import:
+            return KRRApprox(
+                method="falkon",
+                kernel="matern",
+                kernel_params={"sigma": np.sqrt(2 * n_genes), "nu": 1.5},
+                penalization=penalization,
+                M=M,
+            )
+        else:
+            return None
 
     @pytest.fixture(scope="class")
-    def falkon_laplacian_KRR(self):
-        return KRRApprox(
-            method="falkon",
-            kernel="laplacian",
-            kernel_params={"sigma": np.sqrt(2 * n_genes)},
-            penalization=penalization,
-            M=M,
-        )
+    def falkon_laplacian_KRR(self, falkon_import):
+        if falkon_import:
+            return KRRApprox(
+                method="falkon",
+                kernel="laplacian",
+                kernel_params={"sigma": np.sqrt(2 * n_genes)},
+                penalization=penalization,
+                M=M,
+            )
+        else:
+            return None
 
     @pytest.fixture(scope="class")
     def fit_falkon_rbf_ridge(self, falkon_rbf_KRR, input, embedding):
+        if falkon_rbf_KRR is None:
+            return None
         return falkon_rbf_KRR.fit(input, embedding)
 
     @pytest.fixture(scope="class")
     def fit_falkon_laplacian_ridge(self, falkon_laplacian_KRR, input, embedding):
+        if falkon_laplacian_KRR is None:
+            return None
         return falkon_laplacian_KRR.fit(input, embedding)
 
     @pytest.fixture(scope="class")
     def fit_falkon_matern_ridge(self, falkon_matern_KRR, input, embedding):
+        if falkon_matern_KRR is None:
+            return None
         return falkon_matern_KRR.fit(input, embedding)
 
     ###
@@ -131,9 +158,10 @@ def test_all_sklearn_kernels(self):
             KRRApprox(kernel=kernel, method="sklearn")
         return True
 
-    def test_all_falkon_kernels(self):
-        for kernel in KRRApprox.falkon_kernel:
-            KRRApprox(kernel=kernel, method="falkon")
+    def test_all_falkon_kernels(self, falkon_import):
+        if falkon_import:
+            for kernel in KRRApprox.falkon_kernel:
+                KRRApprox(kernel=kernel, method="falkon")
         return True
 
     ###
@@ -160,32 +188,37 @@ def test_laplacian_sklearn_fit(self, fit_sklearn_laplacian_ridge, valid_input, v
     ###
 
     def test_rbf_falkon_fit(self, fit_falkon_rbf_ridge, valid_input, valid_embedding):
-        pred = fit_falkon_rbf_ridge.transform(valid_input)
-        pearson_corr = scipy.stats.pearsonr(pred.flatten(), valid_embedding.detach().numpy().flatten())
-        assert pearson_corr[0] > pearson_threshold
+        if fit_falkon_rbf_ridge is not None:
+            pred = fit_falkon_rbf_ridge.transform(valid_input)
+            pearson_corr = scipy.stats.pearsonr(pred.flatten(), valid_embedding.detach().numpy().flatten())
+            assert pearson_corr[0] > pearson_threshold
 
     def test_matern_falkon_fit(self, fit_falkon_matern_ridge, valid_input, valid_embedding):
-        pred = fit_falkon_matern_ridge.transform(valid_input)
-        pearson_corr = scipy.stats.pearsonr(pred.flatten(), valid_embedding.detach().numpy().flatten())
-        assert pearson_corr[0] > pearson_threshold
+        if fit_falkon_matern_ridge is not None:
+            pred = fit_falkon_matern_ridge.transform(valid_input)
+            pearson_corr = scipy.stats.pearsonr(pred.flatten(), valid_embedding.detach().numpy().flatten())
+            assert pearson_corr[0] > pearson_threshold
 
     def test_laplacian_falkon_fit(self, fit_falkon_laplacian_ridge, valid_input, valid_embedding):
-        pred = fit_falkon_laplacian_ridge.transform(valid_input)
-        pearson_corr = scipy.stats.pearsonr(pred.flatten(), valid_embedding.detach().numpy().flatten())
-        assert pearson_corr[0] > pearson_threshold
+        if fit_falkon_laplacian_ridge is not None:
+            pred = fit_falkon_laplacian_ridge.transform(valid_input)
+            pearson_corr = scipy.stats.pearsonr(pred.flatten(), valid_embedding.detach().numpy().flatten())
+            assert pearson_corr[0] > pearson_threshold
 
     def test_ridge_coef_sklearn_fit(self, fit_sklearn_laplacian_ridge, input, valid_input):
-        pred_reconstruct = fit_sklearn_laplacian_ridge.kernel_(
-            valid_input, input[fit_sklearn_laplacian_ridge.ridge_samples_idx_, :]
-        )
-        pred_reconstruct = pred_reconstruct.dot(fit_sklearn_laplacian_ridge.sample_weights_)
-        np.testing.assert_array_almost_equal(
-            pred_reconstruct, fit_sklearn_laplacian_ridge.transform(valid_input), decimal=3
-        )
+        if fit_sklearn_laplacian_ridge is not None:
+            pred_reconstruct = fit_sklearn_laplacian_ridge.kernel_(
+                valid_input, input[fit_sklearn_laplacian_ridge.ridge_samples_idx_, :]
+            )
+            pred_reconstruct = pred_reconstruct.dot(fit_sklearn_laplacian_ridge.sample_weights_)
+            np.testing.assert_array_almost_equal(
+                pred_reconstruct, fit_sklearn_laplacian_ridge.transform(valid_input), decimal=3
+            )
 
     def test_ridge_coef_falkon_fit(self, fit_falkon_laplacian_ridge, input, valid_input):
-        pred_reconstruct = fit_falkon_laplacian_ridge.kernel_(valid_input, fit_falkon_laplacian_ridge.anchors())
-        pred_reconstruct = pred_reconstruct.matmul(fit_falkon_laplacian_ridge.sample_weights_)
-        np.testing.assert_array_almost_equal(
-            pred_reconstruct, fit_falkon_laplacian_ridge.transform(valid_input), decimal=3
-        )
+        if fit_falkon_laplacian_ridge is not None:
+            pred_reconstruct = fit_falkon_laplacian_ridge.kernel_(valid_input, fit_falkon_laplacian_ridge.anchors())
+            pred_reconstruct = pred_reconstruct.matmul(fit_falkon_laplacian_ridge.sample_weights_)
+            np.testing.assert_array_almost_equal(
+                pred_reconstruct, fit_falkon_laplacian_ridge.transform(valid_input), decimal=3
+            )

tests/test_sobolev_alignment.py

@@ -13,6 +13,14 @@
 frac_save_artificial = 0.1
 
 
+@pytest.fixture(scope="module")
+def falkon_import():
+    try:
+        return True
+    except ImportError:
+        return False
+
+
 @pytest.fixture(scope="module")
 def source_data():
     poisson_coef = np.random.randint(1, 25, size=n_genes)
@@ -87,20 +95,38 @@ def target_scvi_params():
 
 class TestSobolevAlignment:
     @pytest.fixture(scope="class")
-    def sobolev_alignment_raw(self, source_scvi_params, target_scvi_params):
+    def sobolev_alignment_raw(self, falkon_import, source_scvi_params, target_scvi_params):
+        if falkon_import:
+            source_krr_params = {"method": "falkon"}
+            target_krr_params = {"method": "falkon"}
+        else:
+            source_krr_params = {"method": "sklearn"}
+            target_krr_params = {"method": "sklearn"}
+
         return SobolevAlignment(
             source_scvi_params=source_scvi_params,
             target_scvi_params=target_scvi_params,
+            source_krr_params=source_krr_params,
+            target_krr_params=target_krr_params,
             source_batch_name=None,
             target_batch_name=None,
             no_posterior_collapse=False,
         )
 
     @pytest.fixture(scope="class")
-    def sobolev_alignment_batch(self, source_scvi_params, target_scvi_params):
+    def sobolev_alignment_batch(self, falkon_import, source_scvi_params, target_scvi_params):
+        if falkon_import:
+            source_krr_params = {"method": "falkon"}
+            target_krr_params = {"method": "falkon"}
+        else:
+            source_krr_params = {"method": "sklearn"}
+            target_krr_params = {"method": "sklearn"}
+
         return SobolevAlignment(
             source_scvi_params=source_scvi_params,
             target_scvi_params=target_scvi_params,
+            source_krr_params=source_krr_params,
+            target_krr_params=target_krr_params,
             source_batch_name="batch",
             target_batch_name="batch",
             n_artificial_samples=n_artificial_samples,